记忆C++的语法很难，光记忆语法也没有用，不如在简单的代码中，体味C++的语法，用实战方式，学习和巩固这些知识。无论有多难的程序，也是由简单的程序组成的，所以，基础知识牢固，才能做出成绩，本着此想法，开始写这篇文章。

 一有关指针的基础知识

 1.1定义，代码这样实现的：

#include <iostream>
using namespace std;
int main( )
{
       int a,b;                                     //定义整型变量a,b
       int *pointer_1,*pointer_2;   //定义指针变量*pointer_1,*pointer_2
       a=100;b=10;                           //对a,b赋值
       pointer_1=&a;                        //把变量a的地址赋给pointer_1
       pointer_2=&b;                        //把变量a的地址赋给pointer_2
       cout<<a<<" "<<b<<endl;     //输出a和b的值
       cout<<*pointer_1<<" "<<*pointer_2<<endl;  //输出*pointer_1和*pointer_2的值
       return 0;
}

    具体一个应用是这样的：输出两个数中，最大与最小值:

#include <iostream>
using namespace std;
int main( )
{
       int *p1,*p2,*p,a,b;
       cin>>a>>b;  //输入两个整数
       p1=&a;  //使p1指向a
       p2=&b;  //使p2指向b
       if(a<b)  //如果a<b就使p1与p2的值交换
       {
          p=p1;p1=p2;p2=p; //将p1的指向与p2的指向交换
       }
       cout<<"a="<<a<<" b="<<b<<endl;
       cout<<"max="<<*p1<<" min="<<*p2<<endl;
       return 0;
}

用指针交换了指向。

1.2用指针做为函数的参数：

     函数的参数，直接定义成指针，调用时，直接传入指针

#include  <iostream>
using namespace std;
int main( )
{
   void swap(int *p1,int *p2); //函数声明
   int *pointer_1,*pointer_2,a,b; //定义指针变量pointer_1,pointer_2,整型变量a,b
   cin>>a>>b;
   pointer_1=&a; //使pointer_1指向a
   pointer_2=&b; //使pointer_2指向b
   if(a<b) swap(pointer_1,pointer_2); //如果a<b,使*pointer_1和*pointer_2互换
   cout<<"max="<<a<<" min="<<b<<endl; //a已是大数,b是小数
   return 0;
}

void swap(int *p1,int *p2) //函数的作用是将*p1的值与*p2的值交换
{
   int temp;
   temp=*p1;       
   *p1=*p2;
   *p2=temp;         
}

1.3数组与指针

用于排序方面的例子，其实本质上，数组是用指针来实现的特殊变量。

#include <iostream>
using namespace std;
int main( )
{
    void select_sort(int *p,int n); //函数声明
    int a[10],i;
    cout<<"enter the originl array："<<endl;
    for(i=0;i<10;i++) //输入10个数
        cin>>a[i];
    cout<<endl;
    select_sort(a,10); //函数调用,数组名作实参
    cout<<"the sorted array："<<endl;
    for(i=0;i<10;i++) //输出10个已排好序的数
        cout<<a[i]<<"  ";
    cout<<endl;
    return 0;
}

void select_sort(int *p,int n) //用指针变量作形参
{
    int i,j,k,t;
    for(i=0;i<n-1;i++)
    {
        k=i;
        for(j=i+1;j<n;j++)
            if(*(p+j)<*(p+k)) k=j; //用指针法访问数组元素
        t=*(p+k);
        *(p+k)=*(p+i);
        *(p+i)=t;
    }
}

1.4字符指针字符串

#include <iostream>
using namespace std;
int main( )
{
    char *str="I love CHINA!";
    cout<<str<<endl;
    return 0;
}

1.5函数指针

#include <iostream>
using namespace std;
int main( )
{
    int max(int x,int  y);  //函数声明
    int (*p)(int,int);  //定义指向函数的指针变量p
    int a,b,m;
    p=max;  //使p指向函数max
    cin>>a>>b;
    m=p(a,b); //指向了以后要这么用
    //-------------------------------------------
    cout<<"max="<<m<<endl;
    return 0;
}

int max(int x,int y)
{
    int z;
    if(x>y) z=x;
    else z=y;
    return(z);
}

可以很方便地实现用不同的情况下，调用不同的函数方法来处理，动态绑定。

1.6 C ++ 引用

#include <iostream>
#include <iomanip>
using namespace std;
int main( )
{
   int a=10;
   int &b=a;  //声明b是a的引用
   a=a*a;  //a的值变化了，b的值也应一起变化
   cout<<a<<setw(6)<<b<<endl;
   b=b/5;  //b的值变化了，a的值也应一起变化
   cout<<b<<setw(6)<<a<<endl;
   return 0;
}

引用，通俗的说，就是给变量取了其它的名字，相当于我们中国人有大名和小名一样，这样做的好处就是，函数值传递时，参数传递，只是传了个地址，直接在原地进行处理，省去了新开辟一个空间的代价，效率提高。

总结：

  1. 如果看到形参是指针的函数方法，一定传递进去一个地址，用指针或用取变量地址符&，传递进去，就可以正确地调用这个函数。

  2. 如果是看到形参是引用的函数方法，就直接传递变量，来调用这个函数方法。

  3. #include <iostream>
using namespace std;
int main( )
{
   void swap(int &,int &);
   int i=3,j=5;
   swap(i,j);
   cout<<"i="<<i<<"  "<<"j="<<j<<endl;
   return 0;
}

void swap(int &a,int &b)  //形参是引用类型
{
   int temp;
   temp=a;
   a=b;
   b=temp;
}

   上面这个例子，函数的形参是整数型的引用，调用它时，直接给整数型的变量，就可以正确使用它。