C 指针
&：
不能取常数的地址 &10 是错的
#include <stdio.h>
int main()
{
int i=100;
int* p;
p=&i;
//&i的类型：在i类型的基础上再加一个*
//p不能保存常量地址
}
#include <stdio.h> int main() { int i=2; printf("0x%p\n",&i);//&i 取变量i的地址 int suzu[5]={10,20,30,40,50}; printf("0x%p\n",&suzu); //取数组首地址 printf("0x%p\n",suzu); //取数组首地址 printf("0x%p\n",&suzu[0]); //取数组首地址 //以上三个地址是相等的 printf("0x%p\n",&suzu[1]); int *p=&i; //定义指针 //指针变量是用来保存变量地址的 //p指向变量i int *q,*qq; //定义了两个指针 int a=99; int *pp=&a; int x=*pp; //返回指针pp指向的a变量的值---取地址中的值 //[返回变量的值] [*pp相当于a]; *pp=88; //修改变量a的值--修改地址中的值 return 0; }
#include <stdio.h> int main() { int i=20; int * const p =&i; //定义一个const指针 //p保存的地址不能被修改 *p=26; //正确 printf("%d",*p); //p++; //错误 const int *pp=&i; //不能通过*p来修改数据 //*PP=99; 错误 int const *p=&i;//与 const int *pp=&i 一样 //const在*的前面 能通过*p来修改数据 //const在*的后面 指针保存的地址不能被修改 return 0; }
结构体指针：
#include <stdio.h> typedef struct student { int age; int achievement; } Student; int main() { Student stu={18,88}; Student *p=&stu; printf("%d\n",stu.age); printf("%d\n",p->age); //用指针取值 p->age=28; //利用指针修改值 printf("%d\n",p->age); printf("%d----%x\n",p,p); p++; //增加一个结构体的字节数 printf("%d----%x\n",p,p); return(0); }
数组与指针：
#include <stdio.h> //void hansu(int *a){ void hansu(int a[]){ //数组作为参数时，形参与实参是传址 //形参a实际接收的是实参数组的首地址---a实际是指针 //上面两句的效果是一样的 int x=sizeof(a);//参数数组的sizeof返回的是首地址的大小，不是数组元素的总个数；一般需要传递数组的长度 printf("%p\n",a); } int main() { int b[5]={10,20,30,40,50}; int x=sizeof(b); //返回数组元素的总个数 printf("%d\n",x); printf("%p\n",b); //b实际就是指针(常量指针) hansu(b); return 0; }
int a[]={10,20,30,40,50}; int *p=a; printf("p=%p\n",p); printf("p+1=%p\n",p+1); //p=000000000062FE00 //p+1=000000000062FE04 //指针+1时，就是+sizeof(a[0]) ,就是+数据元素的字节数，就是移到下一个元素 //两个指针相减=间隔的元素个数
int* p[5] 与 int(*p)[5] 的区别:
int p[5] :p是指针，指向一个数组(第一个元素地址)，数组中每个元素的类型是int
int* p[5]:p是指针，指向一个数组,数组中每个元素的类型是int类型的指针
int(*p)[5]：数组指针
#include <stdio.h> #include <string.h> int main() { int a[5]={1,2,3,4,5}; int (*p)[5]; //一维数组指针 //p是指针，指向一个空间(空间的大小5个int) p=(int (*)[5])10; //赋值 p=&a; //赋值 int x=(*p)[0]; //取值 //*p相当于a printf("%d\n",x); printf("%p---%d\n",p,p); p++; //自增整个数组空间 printf("%p---%d\n",p,p); int arr[3][3] ={{10,20,30},{40,50,60}}; int (*pp)[3]=&arr[0]; //arr[0]={10,20,30} x=(*pp)[0]; printf("%d\n",x); // x=10 pp++; x=(*pp)[0]; printf("%d\n",x); return(0); }
函数指针：
#include <iostream>
using namespace std;
int add(int a, int b)
{
return a + b;
}
int sub(int a, int b)
{
return a - b;
}
typedef int(*pfunc)(int a, int b);//声明函数指针数据类型
int main()
{
//方法一
int(*p)(int, int) = add; //定义了一个函数指针
//格式：返回类型 (*指针变量名)(参数列表);
int x = p(100, 10);//利用指针调用函数
//方法二
pfunc pf;//创建一个函数指针
pf = sub; //使函数指针指向add函数
x = pf(20, 30);
printf("%d\n", x);
return(0);
}
返回指针：
int s;
int* add(int a, int b) //返回值类型是指针
{
s = a + b;
return &s; //返回指针
}
int main()
{
int* p;
int a = 100;
int b = 10;
p = add(a, b);
cout << p << endl;
cout << *p << endl;
}
++ --的算法：
#include <stdio.h> int main() { char* a=(char*)100; short* b=(short*)100; int* c=(int*)100; printf("%d %d %d\n",a,b,c); a++; b++; c++; //带*变量的++(--)： 自增(自减)去掉一个*之后类型占用的字节数 //不带*变量的++(--)： 自增(自减)1 printf("%d %d %d\n",a,b,c); }
取值运算符：
#include <stdio.h> int main() { //取值运算符：*+指针类型变量 int i=20; int* p=&i; int x=*p; //获取地址中的值 //获取值的类型：指针p类型去掉一个*后的类型 printf("%d\n",x); }
p[n]=*(p+n) p[0][0][0]=***(p) p[1][2]=*(*(p+1)+2)
利用二级指针实现字符串的交换：
#include <iostream> #include <string.h> using namespace std; int main() { char str1[] = "李明"; char* pa = str1; char str2[] = "liming"; char* pb = str2; cout << pa << endl; char** p1 = &pa; char** p2 = &pb; pa = *p2; pb= *p1; cout << pa << endl; return(0); }
