&：
不能取常数的地址 &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);
}
