指针基本问题
指针和引用的差别
★相同点:都是地址的概念;
指针指向一块内存,它的内容是所指内存的地址;引用是某块内存的别名。
★ 区别:
指针是一个实体,而引用仅是个别名;引用使用时无需解引用(*),指针需要解引用;
引用只能在定义时被初始化一次,之后不可变;指针可变;
引用没有 const,指针有 const,const 的指针不可变;
引用不能为空,指针可以为空;由于没有所谓的 null reference 所以所以在使用前不需要进行测试其是否有值.,而使用指针则需要测试其的有效性.
指针未确定指向不能赋值
传递动态内存
1.交换两个数
#include<iostream>
using namespace std;
void swap(int *p,int *q) //不交换,只是指针的交换,地址的值并没有改变
{
int *t;
t=p;
p=q;
q=t;
}
void swap2(int *p,int *q) //成功
{
int t;
t=*p;
*p=*q;
*q=t;
}
void swap3(int &p,int &q) //成功
{
int t;
t=p;
p=q;
q=p;
}
#include<iostream>
using namespace std;
void GetMemory(char * p,int num) //在strcpy时程序崩溃,因为没有传递动态内存,实参一直是NULL
{
p=(char *)malloc(sizeof(char)*num);
}
char * GetMemory1(char * p,int num)
{
p=(char *)malloc(sizeof(char)*num);
return p;
}
void GetMemory2(char ** p,int num)
{
*p=(char *)malloc(sizeof(char)*num);
}
void GetMemory3(int *z)
{
*z=0;
}
int main()
{
char *str =NULL;
str = GetMemory1(str,100);
strcpy(str,"hello");
GetMemory2(&str,100);
strcpy(str,"hello");
cout<<*str; //h
cout<<str; // hello
int a=1;
GetMemory3(&a); //0
cout<<a;
}
3.这个函数有什么问题?用如何修改?
#include<iostream>
using namespace std;
char *strA()
{
char str[]="hello";
return str; // 局部数组 不合理
}
char *strB()
{
char *str="hello";
return str; // 全局数组
}
char *strC()
{
static char str[]="hello";
return str; // 静态
}
9.下卖弄程序在哪一行崩溃?
#include<iostream>
using namespace std;
struct S
{
int i;
int *p;
};
int main()
{
S s;
int *p =& s.i;
p[0]=4;
p[1]=3;
s.p =p;
s.p[1]=1; //相当于*(&s.i+1),即s.i的地址加1,即s.p, s.p[1]与s.p其实是同一个地方,所以到s.p[1]=1,那么s.p[0]将指向内存地址为1的地方
s.p[0]=1; //*((int*)1)=2 ,访问0x00000001空间,对于一个未做声明的地址直接进行访问,所以访问出错
}
函数指针
#include"stdio.h"
int max(int x,int y)
{
return x>y?x:y;
}
int main()
{
int (*p)(int ,int ) = max; //函数指针
int a,b,c,d;
scanf("%d%d%d",&a,&b,&c);
d = (*p)((*p)(a,b),c);
printf("%d",d);
}
float (**def)[10]; //def是一个二级指针,指向的一个一维数组的指针,数组的元素都是float
double * (*gh)[10] //gh是一个指针,指向一个一维数组,数组元素都是double *
double(*f[10]) (); //f是一个10个元素的数组,元素都是函数的指针,指向的类型是无参且返回double的函数。
int * ( (*b)[10] ); //同 int *(*b)[10]
long (*fun)(int) ; //函数指针
int(*(*F)(int ,int))(int);//F是一个函数指针,指向的函数类型是两个int参数且返回一个函数指针的函数,返回的函数指针带有一个参数且返回int.
指针数组和数组指针
p是一个指针变量,它指向包含5个int元素的一维数组,此时p的增量以它所指向的一维数组长度为单位;
*p+i是二维数组a[0][i]的地址;
*(p+2)+3表示a[2][3]地址(第一行为0行,第一列为0列),*(*(p+2)+3)表示a[2][3]的值。
//(*p)[5]其中的5换成其他的数字在vc++6.0环境中都无法通过编译
指针数组:
int *p[] //数组元素全为指针的数组,ptr里存的是地址,指向位置的值是*ptr[0]、*ptr[1].....
char *n[3]={"gain","much","strong"}; n[0]="gain"、n[1]、n[2]
#include<iostream>
using namespace std;
int main()
{
int v[2][10]={1,2,3,4,5,6,7,8,9,10,
11,12,13,14,15,16,17,18,19,20};
int (*p)[10]=v;
cout<<**p<<endl; //1
cout<<**(p+1)<<endl; //11
cout<<*(*p+1)<<endl; //2
cout<<*(p[0]+1)<<endl; //2
cout<<*(p[1])<<endl; //11
cout<<(*p)[12]<<endl; //13
}
#include<iostream>
using namespace std;
int main()
{
int Test[3]={1,2,3};
int *p=(int*)(&Test+1); //Test后面一个位置
cout<<*(p-1); //3
}
4.
指针和句柄
指针指向系统中物理内存的地址,而句柄是windows在内存中维护的一个对象内存物理地址列表的整数索引,标记系统资源隐藏系统信息,一种指向指针的指针。
在windows系统中的内存管理一般会将当前处于空闲状态的对象的内存释放掉,当需要访问的时候再重新提交分配物理内存,从而导致对象的物理地址是变化的,
这样就不允许系统直接通过指针来访问(物理地址不断变化)的对象。
句柄是一种指向指针的指针。由于windows是一种以虚拟内存为基础的操作系统,其内存管理器经常会在内存中来回的移动对象,以此来满足各种应用程序对内存的需求。
而对象的移动意味着对象内存地址的变化,正是因为如此,如果直接使用指针,在内存地址被改变后,系统将不知道到哪里去再调用这个对象。
windows系统为论文解决这个问题,系统专门为各种应用程序腾出了一定的内存地址(句柄)专门用来记录这些变化的地址(这些内存地址就是指向指针的指针),这些内存地址本身是一直不变化的。windows内存管理器在移动某些对象之后,他会将这些对象新的内存地址传给句柄,告诉他移动后对象去了哪里。
句柄(稳定的)----->记载着对象在内存中的地址---->对象在内存中的地址(不稳定的)---->记载着实际对象的地址。