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
",&i);//&i 取变量i的地址
    
    int suzu[5]={10,20,30,40,50};
    printf("0x%p
",&suzu);    //取数组首地址 
    printf("0x%p
",suzu);   //取数组首地址
    printf("0x%p
",&suzu[0]);  //取数组首地址
    //以上三个地址是相等的 
    printf("0x%p
",&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
",stu.age); 
   printf("%d
",p->age);  //用指针取值
   
    p->age=28; //利用指针修改值 
    printf("%d
",p->age);
   
   printf("%d----%x
",p,p);
   p++;   //增加一个结构体的字节数 
   printf("%d----%x
",p,p);
   
   return(0);
}

 数组与指针：

#include <stdio.h>


//void hansu(int *a){
void hansu(int a[]){
    //数组作为参数时，形参与实参是传址
    //形参a实际接收的是实参数组的首地址---a实际是指针 
    //上面两句的效果是一样的 
    int x=sizeof(a);//参数数组的sizeof返回的是首地址的大小，不是数组元素的总个数；一般需要传递数组的长度 
    printf("%p
",a);
}

int main()
{
    
    int b[5]={10,20,30,40,50};
    int x=sizeof(b);  //返回数组元素的总个数
    printf("%d
",x);
    printf("%p
",b);  //b实际就是指针(常量指针) 
        
    hansu(b);
    
    
    return 0;
}

int a[]={10,20,30,40,50};
    int *p=a;
    printf("p=%p
",p);
    printf("p+1=%p
",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
",x);
    
    printf("%p---%d
",p,p);
    p++;  //自增整个数组空间 
    printf("%p---%d
",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
",x);
    // x=10
    pp++;
    x=(*pp)[0];
    printf("%d
",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 ", 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
",a,b,c);
    a++;
    b++;
    c++;
    //带*变量的++(--)：  自增(自减)去掉一个*之后类型占用的字节数 
    //不带*变量的++(--)：  自增(自减)1
    printf("%d   %d    %d
",a,b,c);
    
}

取值运算符： 

#include <stdio.h>

int main()
{
    //取值运算符：*+指针类型变量
    int i=20;
    int* p=&i;
    int x=*p;  //获取地址中的值
    //获取值的类型：指针p类型去掉一个*后的类型 
    
    printf("%d
",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);
}