VC中的指针操作

VC中的指针操作

  指针使用灵活,但也最易犯错,当指针指定到错误的地址往往很不容易调试.
因此掌握指针的正确使用是C ++ 编程的一门基本功.

   本文有关的指针操作:
    // *1**********使用指针与地址运算符*************
     // *p表示p地址内指示的内容,p表示存储地址. 
     // 赋值时*p赋予所指变量的内容信息*p=a; 
     // p用来赋予所指变量的地址信息p=&a.
     // 输出时p用来输出所指变量的内容信息,&p用来输出p的地址信息.
    
     // 指针类型在使用时,不可指向不存在的(void)位置,否则会造成不可预料的结果,
     // 基本上指针遵循下述两种情况:
     // 1.指向已存在的措针
     // 2.要求分配内存自行使用(或内存管理)
    UsePoints();
     // *2**********指针地址运算*********************
     // char *ch ; ch++;ch--;char类型在内存中占一个字节空间,地址增减量为1. 
     // int *ptr; 4
     // float *f; 4
     // double *d; 8
     // *p++;p++;*--p;*++p;(*p)++;(*p)--;
    CalAddressOfPointer();
     // *3**********指针的内存配置********************
     // 配置单一内存
     // 配置单一内存并赋值
     // 配置多个内存,此种方式以指针当数组使用,又有固定大小或弹性大小.
     PointerMemSet();
      // *4*********指针变量与二维数组*****************
     ArrayAndPointer();
      // *5*********指针与函数*************************
      // 一般变量传递参数给指针,再返回来.
     VariMemberAndPointer();
      // 传址方式传参数
      // 使用地址运算符"&"也可实现,将数据从函数的参数部分返回参数.
     VariAddAndFunction();
      // 前两种方法的混合使用
     VariAndPointer();
      // 指针传给指针
      // 大家都是指针,避免传递参数时使用地址运算符"&"不留神时造成的错误.
     PointerAndPointer();
      // 函数名称以指针返回
     PointerFunction();
      // *6******指针与结构******************************
     PointerAndStruct();
      // *7******指针的指针(双指针)**********************
     DoublePointer();
      // *8******以双重指针来赋值二维数组****************
     DoublePointerAndArray();
      // *9******指针指向函数****************************
     PointerToFunction();
      // *10*****指针数组********************************
     PointerArray();
      // *11*****字符数组与字符串的常数设置**************
     CharArrayAndString();
      // *12*****类的指针传递****************************
     UseDataHelperArray();

     详细代码:

// ***********使用指针与地址运算符*************
// *p表示p地址内指示的内容,p表示存储地址. 
// 赋值时*p赋予所指变量的内容信息*p=a; 
// p用来赋予所指变量的地址信息p=&a.
// 输出时p用来输出所指变量的内容信息,&p用来输出p的地址信息.
// 指针类型在使用时,不可指向不存在的(void)位置,否则会造成不可预料的结果,
// 基本上指针遵循下述两种情况:
// 1.指向已存在的措针
// 2.要求分配内存自行使用(或内存管理)
void  UsePoints()
{
    int x=10;
    int *p4;
    cout<<"**********************************"<<endl;
    //p4=x; //错误.将数值10赋给存储地址的指针是不对的.
    //*p4=x; //错误,p4还没有指向内存的地址,不能给它赋值.
    p4=&x;   //p4指向x的地址
    cout<<"x中的值   :"<<x<<endl;   //10  
    cout<<"x的地址   :"<<&x<<endl;  //0x0012FF28
    cout<<"p4中的内容:"<<p4<<endl;  
    //p4中保存了x在内存中的地址.即&x与p4值相同.p4保存了x的地址.
    cout<<"p4的地址  :" <<&p4<<endl; //p4的地址.与x的地址不同.
    cout<<"取出p4所指地址中的内容:"<<*p4<<endl; 
    cout<<"**********************************"<<endl;
    //指针赋值.
    //指针类型之间可以互相赋值,即可以使许多指针指向同一个地址.
    int *p1;
    p1=p4;
    cout<<"p1=p4操作"<<endl;
    cout<<"p1中的内容:"<<p1<<endl;  
    //p1中保存了x在内存中的地址.即&x与p1值相同.p1保存了x的地址.
    cout<<"p1的地址  :" <<&p1<<endl; //p1的地址.与x,p4的地址不同.
    cout<<"取出p1所指地址中的内容:"<<*p1<<endl; 
    
    cout<<"P4要求分配4个字节的内存空间自行使用"<<endl;
    p4=new int; //P4要求分配4个字节的内存空间自行使用.
    *p4=x; 
    cout<<"p4:"<<*p4<< " &x: "<<&x <<" &p4: "<<&p4<<endl;  
    //值:10,0x0012FF28,0x0012FF24
    cout<<"**********************************"<<endl;
}
// ***********指针地址运算*********************
     // char *ch ; ch++;ch--;char类型在内存中占一个字节空间,地址增减量为1. 
     // int *ptr; 4
     // float *f; 4
     // double *d; 8
     // *p++;p++;*--p;*++p;(*p)++;(*p)--;
void  CalAddressOfPointer()
{
    cout<<"**********************************"<<endl;
    int *p,a=10;
    p=&a;
    (*p)++; //表示先输出*p的内容后,再而p++.其主要原因是*运算符拥有最高优先级;
    cout<<"*p,a: "<< *p<<", "<<a<<endl; //11,11 均增1.
    *p++;   //表示先输出*p中内容11后,再p中的地址加1.
    cout<<"*p++:"<<*p<<endl;//1244968(p+1地址中的数,因机而异.)
    *p--;   
    cout<<"*p--:"<<*p<<endl;//11.
    *++p;
    cout<<"*++p:"<<*p<<endl;//1244968(p+1地址中的数,因机而异.)
    *--p;
    cout<<"*--p:"<<*p<<endl;//11
    cout<<"**********************************"<<endl;
    //数组访问, p1++的使用.
    int b[6]={1,2,3,4,5,6};
    int *p1=b;
    for(int i=0;i<6;i++)
    {
        cout<<"各元素地址:"<<endl;
        cout<<"b["<<i<<"]"<<&b[i]<<endl;
        cout<<"*p1内容:"<<*p1<<endl;
        cout<<"p1地址:"<<p1<<endl;
        cout<<"++(*p1):"<<++(*p1)<<endl; 
        //先*p取出数据,然后对取出的数据加1.
        cout<<"(*p1)++:"<<(*p1)++<<endl;
        cout<<"p1地址:"<<p1<<endl;
        p1++;  //通过指针中的地址递增访问数组b中的数据.
    }
    cout<<endl;
    //p1=b; 
    //或
    p1=&b[0];
    for(int w=0;w<6;w++)
        cout<<p1++<<"  "<<*p1<<endl;
    cout<<"**********************************"<<endl;
    //字符数组的访问,*p3++的使用.
    char s2[10]="Morning";
    char *p3=s2;
    cout<<"一次输出一个字符"<<endl;
    int ilen=strlen(s2);
    //for(int j=0;j<ilen;j++)
    //或
    while(*p3)
        cout<<*p3++<<","; //M,o,r,n,i,n,g,
    cout<<endl;
    cout<<"**********************************"<<endl;
    p3=s2;
    for(int j=0;j<ilen;j++)
        cout<<p3++<<endl;   //输出p3所指的内容,非地址值;
    //Monrning,onrning,g;
    cout<<"**********************************"<<endl;
    char s[10]="Howareyou";
    char *p2=s; //*p2中存储s的内容.
    //指针p2变量占用4个字节的存储空间,用来存储s的地址信息;
    cout<<"p2指原内容:"<<p2<< " &p2地址:"<<&p2<<" &s地址:"<<&s<<endl; 
    //Howareyou,OX0012FEF4,OX0012FEF8
    p2++;  //p2中存储的s地址信息加1.
    cout<<"p2++后内容:"<<p2<<" &p2地址:"<<&p2<<" &s地址:"<<&s<<endl; 
    //owareyou,OX0012FEF4,OX0012FEF8
    cout<<"**********************************"<<endl;
    char *str;
    if((str=(char*)malloc(21))==NULL)
    {
        cout<<"内存不足"<<endl;
        exit(1);
    }
    strcpy(str,"goodMorning");  //将goodMorning复制给str.
    strcpy(s,str);
    cout<<"所复制的数据为:"<<str<< endl;
    cout<<"长度:"<<strlen(str)<<endl;
    cout<<"**********************************"<<endl;
    //p2=str;
    //指针p2变量占用4个字节的存储空间,用来存储s的地址信息;
    cout<<"p2指原内容:"<<p2<< " &p2地址:"<<&p2<<" &s地址:"<<&s<<"s现在的值: "<<s<<endl; 
    //oodMorning,OX0012FEF4,OX0012FEF8,goodMoning
    p2++;  //p2中存储的s地址信息加1.
    cout<<"p2++后内容:"<<p2<<" &p2地址:"<<&p2<<" &s地址:"<<&s<<"s现在的值: "<<s<<endl; 
    //odMorning,OX0012FEF4,OX0012FEF8,goodMoning    
    free(str);
    cout<<"**********************************"<<endl;

}
     // ***********指针的内存配置********************
     // 配置单一内存
     // 配置单一内存并赋值
     // 配置多个内存,此种方式以指针当数组使用,又有固定大小或弹性大小.
void  PointerMemSet()
{
cout<<"**********************************"<<endl;
//配置单一内存    
 int *a,b;
 a=new int;
 cout<<"a的地址:"<<a<<endl;
 cout<<"b的地址:"<<&b<<endl;
 *a=2;
 *a+=6;
 cout<<setw(6)<<"*a+6="<<setw(6)<<*a<<endl;
 delete a;
cout<<"**********************************"<<endl;

//配置多个内存
int n;
n=16;
int *b3;
b3=new int[n];
int i=0;
for(i=0;i<n;i++)
{
    *(b3+i)=rand()%16;
    cout<<*(b3+i)<<",";
}
delete [] b3;
cout<<endl;
cout<<"**********************************"<<endl;
//c语言中的malloc与free写法,#include<stdlib.h> 或#include<alloc.h>
//要注意内存大小的匹配 char: 1; int: 4;float: 4;
int *a2;
if((a2=(int *)malloc(6*sizeof(int)))==NULL)
{
    cout<<"内存不足"<<endl;
    exit(1);
} //对
//a2=(int *)malloc(17);//错误,配置17个字节的内存,非int类型所占内存的倍数.
for(i=0;i<6;i++)
{
    *(a2+i)=rand()%16;
    cout<<*(a2+i)<<",";
}
cout<<endl;
free(a2);
cout<<"**********************************"<<endl;

}

// **********指针变量与二维数组*****************
void  ArrayAndPointer()
{
    cout<<"**********************************"<<endl;
    //指针变量与二维数组
    const int w=3,y=4;  //注意要定义为const,以便后面的int a[i][j]使用;
    int a[w][y],*p;
    int i=w,j=y;
    p=&a[0][0];  //p中只保存有a[0][0]的地址,p+m是地址值增加.
    int m=0;
    cout<<"&p="<<&p<<endl;
    for(m=0;m<w*y;m++)
    {
        *(p+m)=rand()%12;
        cout<<*(p+m)<<" ";
    }

    cout<<endl<<"数组内容为"<<endl;
    
    
    for(m=0;m<3;m++)
            for(int n=0;n<4;n++)
            {
                cout.width(3); //设置输出的字符宽度
                cout<<*(*(a+m)+n)<<"  ";
            }
    cout<<endl<<"&p="<<&p<<endl;

    //delete p;
    cout<<"**********************************"<<endl;
}
// *5*********指针与函数*************************
// 函数与指针的可能组合
声明         调用            函数定义               说明
int  a;       fc1( & a,);     void  fc1( int   * a,)   指针参数返回
int  a;       fc1(a,);      void  fc1( int   & a,)   指针参数返回
int   * a;      fc1(a,);      void  fc1( int   * a,)   指针参数返回
int   * a;      a = fc1();      int    * fc1()         函数名返回
int   * a, * b;   a = fc1(b,);    int    * fc1( int   * b,)  函数名返回,指针参数返回
// 一般变量传递参数给指针,再返回来.
int   Cal_data( int   * a, int   * b)
{
    int t;
    t=*a+100;
    *a=*b;
    *b=t+200;
    return *b;
}
int  VariMemberAndPointer()
{
    int a,b;
    a=10;
    b=16;
    cout<<"运算前:  a="<<a<<" b= "<<b<<endl;
    cout<<Cal_data(&a,&b)<<endl ; //将两个变量的地址传给参数.
    cout<<"运算后:  a="<<a<<" b= "<<b<<endl; //a=16,b=310;
    return 1;
}

// ***********************************
// 传址方式传参数
// 使用地址运算符"&"也可实现,将数据从函数的参数部分返回参数.
// 通过指针与引用进行数据传递,可使程序在调用函数上更为灵活,但必须注意
// 传递参数的相互关系
/**/ /
主程序调用                   函数定义
int  a, * b;
fc1( & a);         ->             void  fc1( int   * a)
fc1(a);          ->            VOID fc1( int   & a)  
fc1(b);          ->            VOID fc1( int   * b)  
/**/ /
int   Cal_data( int   & , int   & ); // 先声明

  int  VariAddAndFunction()
  {
     int a,b;
     a=10;
     b=16;
     cout<<"运算前:  a="<<a<<" b= "<<b<<endl;
     cout<<Cal_data(a,b)<<endl ; //将两个变量的地址传给参数.
     cout<<"运算后:  a="<<a<<" b= "<<b<<endl; //a=16,b=310;
     return 1;
 }
  int   Cal_data( int   & a, int   & b)
  {
     int t;
     t=a+100;  //不能使用t=*a+100; *a为指针类型.
     a=b;
     b=t+200;
     return b;
 }
// *********************************************
// 前两种方法的混合使用
int   Cal_data( int   & a, int   * b);
  VariAndPointer()
   {
      int a,b;
      a=10;
      b=16;
      cout<<"运算前:  a="<<a<<" b= "<<b<<endl;
      cout<<Cal_data(a,&b)<<endl ; //将两个变量的地址传给参数.
      cout<<"运算后:  a="<<a<<" b= "<<b<<endl; //a=16,b=310;
      return 1;  
  }
   int   Cal_data( int   & a, int   * b)
   {
      int t;
      t=a+100;  //不能使用t=*a+100; *a为指针类型.
      a=*b;
      *b=t+200;
      return *b;
  }
   // 指针传给指针
   // 大家都是指针,避免传递参数时使用地址运算符"&"不留神时造成的错误.
   int  Get_Data( int   * a, int   * b)
   {
     
      *a=10;
      *b=20;
      return *b;
  }
int  PointerAndPointer()
{
    int *a,*b;

    a=new int;
    b=new int;
    cout<<Get_Data(a,b);
    cout<<"取出a,b的值"<<*a<<"  "<<*b<<endl;
    delete a;
    delete b;
    return 1;
}
// 函数名称以指针返回
int   * Get_data1( int  , int );
int   * Get_Array();
char   * Get_String();
int  PointerFunction()
{
    int a=10,b=20,*p;
    p=Get_data1(a,b); 
    cout<<"p="<<*p<<endl;
    delete p;

    int *p2=new int[11];
        cout<<"&p2="<<&p2<<endl;
    p2=Get_Array();
    cout<<"p2=";
    for(int i=0;i<9;i++)
    cout<<*p2++<<",";
    cout<<"&p2="<<&p2<<endl;

    cout<<endl;
    int j=0;
    for ( j=0;j<9;j++)
        //*p2--;
    cout<<"&p2="<<*p2--<<endl;  //一定要加上此句.
    delete [] p2;
    char *p3=new char[13];
    cout<<"&p3="<<&p3<<endl;
    p3=Get_String();
    cout<<"p3="<<p3<<endl;
    cout<<"&p3="<<&p3<<endl;
    int x=sizeof(p3);
    cout<<"p3长度"<<x<<endl;
    for (j=0;j<13;j++)
    cout<<"&p3="<<p3--<<endl;
    //delete [] p3;
    return 1;
}
int   * Get_data1( int  a, int  b)
{
    int *p=new int(a+b);
    return p;
}
int   * Get_Array()
{
    int *p=new int[11];
    for(int i=0;i<9;i++)
        *(p+i)=i*2;
    return p;
}
char   * Get_String()
{
    char *p=new char[13];
    p="good morning";
    return p;
}
// 指针与结构
typedef  struct  student
{
char name[4];
char sex;
int age;
} _student;
void  get_student(student  * a)
{

    
    a->name[0] ='b';
    a->name[1] ='l';
    a->name[2] ='g';
    a->name[3] ='c';

    a->sex ='f';
    a->age =23;
}
int  PointerAndStruct()
{
   student blgc;
get_student(&blgc);
cout<<"name="<<blgc.name <<endl;
cout<<"sex="<<blgc.sex  <<endl;
cout<<"age="<<blgc.age  <<endl;

return 1;
}
// 指针的指针(双指针)
int  DoublePointer()
{
    //*p  地址->内容
    //**p 地址->地址->内容
    int x,*p,**p2;
    x=100;
    p=&x;
    p2=&p;
    cout<<"*p="<<*p<<endl;  //100
    cout<<"&p="<<&p<<endl;  //0x0012FF24
    cout<<"*p2="<<*p2<<endl; //0x0012FF28
    cout<<"**p2="<<**p2<<endl; //100
    return 1;
}
// 以双重指针来赋值二维数组
// 先要求行的指针,再以行的指针来赋值列的指针,使行为第一指针,
// 列为第二指针,形成数组的数组,其访问方式可用一般数组的访问方式.
const   int  row = 2 ;
const   int  col = 3 ;
int  Get_Array( float   ** data)
{
    srand((unsigned)time(NULL));//启动随机函数生成器
    randomize();
    int temp=0;
    for(int i=0;i<row;i++)
        for(int j=0;j<col;j++)
        {
            temp=random(10); //产生0-9的随机数
            data[i][j]=(float)temp;
        }
           return 1;
}
void  Display( float   ** data)
{
for(int i=0;i<row;i++)
{
    for(int j=0;j<col;j++)
            cout<<data[i][j]<<" ";
cout<<endl;
}

}
void  Dispose( float   ** data)
{
    for(int i=0;i<row;i++)
    {
        delete [] data[i]; //释放列
    }
    delete [] data; //释放行
}
 
int  DoublePointerAndArray()
{

float **data;
try
{
    data=new float *[row];  //配置行
    for(int j=0;j<row;j++)
        data[j]=new float[col]; //配置列
    throw(1); //自定义抛出一个异常数字1.
}
catch(int err)
{
    if(err!=1)
    {
        cout<<"内存不足,"<<endl;
        exit(-1);
    }
}
Get_Array(data);
Display(data);
Dispose(data); //释放内存
return 1;
}
// 指针指向函数
// 函数虽然不是变量,但它仍然在内存中有实际地址,故可以将指针指向该地址.
// 要取得函数地址,只要将函数名称赋值给指针变量,而不用任何括号或参数,就
// 象数组的地址赋值给指针变量一样.
double  xpowxy( double , double , double ( * xy)( double , double ));
double  add( double  x , double  y);
int  PointerToFunction()
{
    //指针指向pow函数,用以求x的y次方值.
    double x,y;
    double (*p)(double,double);
    //p=pow;
    p=add;
    x=10;
    y=2;
    //cout<<"x^y="<<xpowxy(x,y,p)<<endl;
    cout<<"x+y="<<xpowxy(x,y,p)<<endl;
    return 1;
}
double  xpowxy( double  x, double  y, double ( * xy)( double  , double ))
{
    return xy(x,y);
}

double  add( double  x , double  y)
{
    return x+y;
}

// 指针数组
int  PointerArray()
{
    int *p[6],i=0;
    for(i=0;i<6;i++) 
    {
        p[i]=new int(i*2); //分配内存空间,赋初值.
    }
    for(i=0;i<6;i++)
    {
        cout<<*p[i]<<endl;  //输出结果
    }
    for(i=0;i<6;i++)
    {
        delete p[i]; //释放资源
    }
    return 1;
}
// 字符数组与字符串的常数设置
const   int  N = 6 ;
int  CharArrayAndString()
{
    int i;
    char s[N]={'a','b','c','d','e'}; //纯字符数组非字符串,没有结束符'\0'

    char st[N+1]={'A','B','C','D','E','\0'};    //纯字符数组的字符串
    char str[]="ABCDE";
    char *string="ABCDE";
    cout<<"字符数组输出s[N]=";
    for (i=0;i<N;i++)
        cout << s[i];
    cout << endl;
    cout <<"字符串输出st[N+1]="<<st<<endl;
    cout <<"字符串输出str[]="<<str<<endl;
    cout <<"字符串输出*string="<<string<<endl;
    return 1;
}


class  DataHelper
{
private :
    int x;
    int a[10];
    
public :
    int *Group1[20];
    static int Group2[20];
    int Group3[20];
    int y;
    static int z;
    DataHelper();
    int GetGroup1();
    int SetGroup2(int b[20]);
} ;

int  DataHelper::z ;  // 静态成员声明,切记.
int  DataHelper::Group2[ 20 ]; 
DataHelper::DataHelper()
{
    x=10;
    y=-1;
    z=-1;
    for(int i=0;i<20;i++)
    {
        Group1[i]=new int(-1);
        Group2[i]=-1;
    }
    memset(Group3,-1,sizeof(Group3));
}
DataHelper::SetGroup2 ( int  b[ 20 ])
{

    for(int i=0;i<20;i++)
    {
      Group2[i]=b[i];
    }
    return 1;
}
int  UseDataHelperArray()
{
    DataHelper *dh;


    dh=new DataHelper();
    *(dh->Group1[0])=10;
    *(dh->Group1[0])=20;
    dh->y=20;
    DataHelper::z=100;

    int a[20];
    
    memset(a,100,sizeof(a));
    dh->SetGroup2(a) ;
    DataHelper::Group2[0]=100;
    
    cout<<"dh->y="<<dh->y <<endl;
    cout<<"dh->Group1[0]="<<*(dh->Group1[0])<<endl;
    cout<<"dh->Group1[1]="<<dh->Group1[1]<<endl;
    cout<<"DataHelper::z"<<DataHelper::z<<endl;
    cout<<endl<<endl;
    
    cout<<"dh2->Group2[0]="<<DataHelper::Group2[0]<<endl;

    DataHelper *dh2;
    dh2=new DataHelper;
    cout<<endl<<endl;
    
    cout<<"dh2->Group1[1]="<<dh2->Group2[1]<<endl;
   
    return 1;

}



#include  < iostream.h > // cout,cin
#include  < iomanip.h > // setw()
#include  < conio.h >   // getch()
# include  < stdio.h >
# include  < stdlib.h >
# include  < string .h >
# include  < time.h >
# include  < math.h >   // pow(x,y)
#define  randomize() srand((unsigned) time(NULL))
#define  random(x) rand()%x
// #include <alloc.h>
#include  < process.h >
// #include <except.h>

// 指针使用灵活,但也最易犯错,当指针指定到错误的地址往往很不容易调试.
// 因此掌握指针的正确使用是C++编程的一门基本功.

// **************
// 指针类型在使用时,不可指向不存在的(void)位置,否则会造成不可预料的结果,
// 基本上指针遵循下述两种情况:
// 1.指向已存在的措针
// 2.要求分配内存自行使用(或内存管理)
// ***************
// 指针下标超出数组范围

posted on 2006-08-25 17:00 DotNet编程 阅读( ...) 评论( ...) 编辑 收藏

转载于:https://www.cnblogs.com/furenjun/archive/2006/08/25/486377.html