指针使用灵活,但也最易犯错,当指针指定到错误的地址往往很不容易调试.
因此掌握指针的正确使用是C++编程的一门基本功.
指针使用灵活,但也最易犯错,当指针指定到错误的地址往往很不容易调试.
因此掌握指针的正确使用是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.要求分配内存自行使用(或内存管理)
//***************
//指针下标超出数组范围
|
