C语言指针详解 函数指针 指针函数

 1为什么使用指针

1.使用指针型变量在很多时候占用更小的内存空间。
2.变量为了表示数据，指针可以更好的传递数据。
(显然，方案二更好一些，方案二类似使用指针传递地址，方案一将内存中的内容重新“复制”了一份，效率比较低。)
3.在数据传递时，如果数据块较大，可以使用指针传递地址而不是实际数据，即提高传输速度，又节省大量内存。
4.数据转换，利用指针的灵活的类型转换，可以用来做数据类型转换.
5.指针的机制比较简单，其功能可以被集中重新实现成更抽象化的引用数据形式
6.数据转换，利用指针的灵活的类型转换，可以用来做数据类型转换，比较常用于通讯缓冲区的填充。
7.指针的机制比较简单，其功能可以被集中重新实现成更抽象化的引用数据形式
8.函数指针，形如: #define PMYFUN (void*)(int,int) ，可以用在大量分支处理的实例当中，
9.在数据结构中，链表、树、图等大量的应用都离不开指针

2 指针是什么？

操作系统将硬件和软件结合起来，给程序员提供的一种对内存使用的抽象，这种抽象机制使得程序使用的是虚拟存储器,而不是直接操作和使用真实存在的物理存储器。
所有的虚拟地址形成的集合就是虚拟地址空间。
 
内存是一个很大的线性的字节数组，每个字节固定由 8 个二进制位组成，每个字节都有唯一的编号.
当程序使用的数据载入内存时，都有自己唯一的一个编号，这个编号就是这个数据的内存指针地址。指针就是这样形成的。

指针不仅可以表示变量的地址，还可以存储各种类型数据的地址，指针变量是用来保存这些地址的变量，
与数组类似，依据地址存放的数据类型，指针也分为 int 指针类型，  double 指针类型， char 指针类型等等。

综上，指针的实质就是数据在内存中的地址，而指针变量是用来保存这些内存地址的变量。

3.指针变量 和 指向关系

用来保存 指针 的变量，就是指针变量。

int num = 97;
int* p = & num; 指针变量p保存了变量 num的地址，p指向了变量num，p指向了num所在的内存块，
int **pp = &p;  指针变量pp指向了p所在的内存块， 

 int型的num值为97占4个字节，内存地址为:0113F924 

 

• num的地址为：0113F924，num的值为 97 ，指针 p 指向 num 的内存块，指针 p 地址为：0113F90C，p的内存保存的值就是num的地址0113F924。

 

• 指针变量 pp 指向 指针 p，指针 pp 内存值为 指针 p 的地址：0113F90C，形成了指向指针的指针。

 

 声明一个指针变量

 

C语言中，定义变量时，在变量名 前 写一个 * 星号，这个变量就变成了对应变量类型的指针变量。必要时要加( ) 来避免优先级的问题。

指针其实就是一个变量，指针的声明方式与一般的变量声明类似.

声明一个指针变量并不会自动分配任何内存。在对指针进行间接访问之前，指针必须进行初始化：或是使他指向现有的内存，或者给他动态分配内存，否则我们并不知道指针指向哪儿，这个问题需要特别关注。

引申：C语言中，定义变量时，在定义的最前面写上typedef ，那么这个变量名就成了一种类型，即这个类型的同义词。

取地址

既然有了指针变量，那就得让他保存其它类型变量的内存地址，使用& 运算符取得一个变量的地址。

特殊的情况，他们并不一定需要使用&取地址：
    
    数组名的值就是这个数组的第一个元素的地址。arr=&arr
    函数名的值就是这个函数的地址。  add=&add; 
    字符串字面值常量作为右值时，就是这个字符串对应的字符数组的名称,也就是这个字符串在内存中的地址。
    

#include <iostream>
using namespace std;


int add(int a , int b)
{
    printf("a+b=%d\n", a + b);
    return a + b;
}


int mainxiaoyuzhizhen(){
    int* p ; //int* 变量p    // 声明一个 int 类型的指针变量 p，该指针指向一个int类型的对象
    int* p_int;  //int* 变量p_int   // 声明一个 int 类型的指针变量p_int，该指针指向一个int类型的对象
    char * cp;         // 声明一个 char 类型的指针变量 cp，该指针指向一个char类型的对象
    double* p_double; //指向double类型变量的指针 p_double
    struct Student* p_struct; //结构体类型的指针p_struct
    int** p_pointer; //指向 一个整形变量指针的指针




    int num = 97;//int 类型变量num
    int* p_num = &num;// 指针变量p_num  保存了变量num的内存地址&num

    float score = 10.00F;//float 类型的变量score
    float* p_score = &score; // 指针变量p_score 保存了变量score的内存地址&score



    int *arr0[10];    // 声明一个指针数组，该数组有10个元素，其中每个元素都是一个指向 int 类型对象的指针 【每一个元素都是指针】
    int (*arr1)[10];  // 声明一个数组指针，该指针指向一个 int 类型的一维数组


    int arr[3] = {1,2,3}; //arr是包含3个int元素的数组变量
     arr; &arr;//int类型的数组arr的内存地址arr   &arr
    int(*p_arr)[3]=&arr; //一个指向   含有3个int元素的数组arr   的指针变量 p_arr  【数组arr的指针变量p_arr】
    printf("指针变量p_arr=%p\n",p_arr); //指针变量p_arr=00A4FEF8

    // 或者这样写
    int(*p_arr2)[3];
     p_arr2=&arr;
    printf("指针变量 p_arr2 =%p\n",p_arr2); //指针变量 p_arr2 =00A4FEF4




     int(*p_func)(int,int);  //指向返回类型为int，有2个int形参的函数的指针变量 p_func  【函数add的指针变量p_func】
      add; &add; //函数add的内存地址add 或者 &add
     // 指针变量p_func 指向 函数add的内存地址add
     p_func=add;
     add(1,2); // a+b=3
    // 指针变量p_func 指向 函数add的内存地址 &add
    p_func=&add;
    add(2,2);  //a+b=4

   // 也可以这样写
    int(*p_funcc)(int,int)=&add;
    add(3,2); // a+b=5


    int arrr[5] = {1,2,3,4,5};
    int* p_first = arr; //  数组名arrr作为右值的时候，就是第一个元素的地址
    int first =*p_first;
    printf("输出数组arrr第一个元素first=%d\n",first); //输出数组arrr第一个元素first=1
     p_first++;
    int second =*p_first;
    printf("输出数组arrr第二个元素second=%d\n",second); //输出数组arrr第二个元素second=2


}

 

解地址

 对一个指针解地址，就可以取到这个内存数据，解地址 的写法，就是在指针的前面加一个 * 号。
    解指针的实质是：从指针指向的内存块中取出这个内存数据。

 int age = 19;
    int*p_age = &age;
    *p_age  = 20;  //通过指针修改指向的内存数据

空指针

  空指针在概念上不同于未初始化的指针。
    空指针可以确保不指向任何对象或函数；
    而未初始化的指针则可能指向任何地方。空指针不是野指针。

在C语言中，我们让指针变量赋值为NULL表示一个空指针，而C语言中，NULL实质是 ((void*)0) ，
    在C++中，NULL实质是0。

void*类型指针

void是一种特殊的指针类型，可以用来存放任意对象的地址。一个void指针存放着一个地址，这一点和其他指针类似。不同的是，我们对它到底储存的是什么对象的地址并不了解。

由于void是空类型，只保存了指针的值，而丢失了类型信息，我们不知道他指向的数据是什么类型的，只指定这个数据在内存中的起始地址，如果想要完整的提取指向的数据，程序员就必须对这个指针做出正确的类型转换，然后再解指针。

double a=2.3;
	void *p=&a;
	cout<<p<<endl;   //输出了a的地址
	
	int b=5;
	p=&b;
	cout<<p<<endl;   //输出了b的地址
	
	//cout<<*p<<endl;这一行不可以执行，void*指针只可以储存变量地址，不可以直接操作它指向的对象

 4.数组和指针

 同类型指针变量可以相互赋值，数组不行，只能一个一个元素的赋值或拷贝
    数组在内存中是连续存放的，开辟一块连续的内存空间。数组是根据数组的下进行访问的。
    指针很灵活，它可以指向任意类型的数据。指针的类型说明了它所指向地址空间的内存。
    
    
    数组所占存储空间的内存：sizeof（数组名）
    数组的大小：sizeof（数组名）/sizeof（数据类型），
    在32位平台下，无论指针的类型是什么，sizeof（指针名）都是 4 ，
    在 64 位平台下，无论指针的类型是什么，sizeof（指针名）都是 8 。
    
    
     数组名作为右值的时候，就是第一个元素的地址
    
    
    指向数组元素的指针 支持 递增 递减 运算。
    p= p+1意思是，让p指向原来指向的内存块的下一个相邻的相同类型的内存块。
    在数组中相邻内存就是相邻下标元素。

 int arrr[5] = {1,2,3,4,5};
    int* p_first = arr; //  数组名arrr作为右值的时候，就是第一个元素的地址
    int first =*p_first;
    printf("输出数组arrr第一个元素first=%d\n",first); //输出数组arrr第一个元素first=1
     p_first++;
    int second =*p_first;
    printf("输出数组arrr第二个元素second=%d\n",second); //输出数组arrr第二个元素second=2

5.函数与指针

 (1)函数的参数和指针

C语言中，实参传递给形参，是按值传递的，也就是说，函数中的形参是实参的拷贝份，形参和实参只是在值上面一样，而不是同一个内存数据对象。这就意味着：这种数据传递是单向的，即从调用者传递给被调函数，而被调函数无法修改传递的参数达到回传的效果。

C语言中，实参传递给形参，是按值传递的，也就是说，函数中的形参是实参的拷贝份，形参和实参只是在值上面一样，
    而不是同一个内存数据对象。
    这就意味着：这种数据传递是单向的，即从调用者传递给被调函数，而被调函数无法修改传递的参数达到回传的效果。

   有时候我们可以使用函数的返回值来回传数据，在简单的情况下是可以的，
    但是如果返回值有其它用途（例如返回函数的执行状态量），
    或者要回传的数据不止一个，返回值就解决不了了。

void change(int a)
{
    a++;      //在函数中改变的只是这个函数的局部变量a，而随着函数执行结束，a被销毁。age还是原来的age，纹丝不动。
}


//传递变量的指针可以轻松解决上述问题。
void change(int* pa)
{
    (*pa)++;   //因为传递的是age的地址，因此pa指向内存数据age。当在函数中对指针pa解地址时，
               //会直接去内存中找到age这个数据，然后把它增1。
}



int main(void)
{
    int age = 60;
    change(age);
    printf("age = %d",age);   // age = 60
    change(&age);
    printf("age = %d",age);   // age = 61
    return 0;
}

(2)函数的指针

函数指针定义：函数指针是指向函数的指针变量。因此“函数指针”本身首先应是指针变量，只不过该指针变量指向函数。这正如用指针变量可指向整型变量、字符型、数组一样，这里是指向函数。

一个函数总是占用一段连续的内存区域，函数名在表达式中有时也会被转换为该函数所在内存区域的首地址。
     我们可以把函数的这个首地址赋予一个指针变量，使指针变量指向函数所在的内存区域，然后通过指针变量就可以找到并调用该函数。
    这种指针就是函数指针。

   函数指针的定义格式如下：

    函数返回值类型     (*函数指针变量名称)      (函数参数列表)
    returnType (*pointerName)(param list);

 returnType 为函数返回值类型

 pointerNmae 函数指针变量名称

 param list 为函数参数列表 【参数列表中可以同时给出参数的类型和名称，也可以只给出参数的类型，省略参数的名称，这一点和函数原型非常类似。】

typedef int(*p_func)(int,int);//函数指针的定义

typedef void (*fun)(void); //函数指针fun的定义 //无参数和返回值

typedef int (*fun)(void)  //函数指针fun的定义

typedef void* (*Fun4)(void*);//参数和返回值都为void*指针

typedef int (*fun)(int )  //函数指针fun的定义

typedef int (*fun)(int x)  //函数指针fun的定义

typedef int (*fun)(int ，int ) //函数指针fun的定义
typedef int (*fun)(int x，int y) //函数指针fun的定义

typedef   char* (*pFunction)(char* p1,char* p2);  //函数指针pFunction的定义

 函数指针的赋值

    函数指针和其他指针一样定义之后使用之前也是需要初始化。
    函数指针有两个用途：调用函数和做函数的参数

      p_func=add;  
      p_func=&add;   
      pFunction=&function;  

函数指针的调用 

 我们使用指针的时候，需要通过钥匙 * 来取其指向的内存里面的值，函数指针使用也如此。通过用(*pf)取出存在这个地址上的函数，然后调用它。

用函数指针调用函数的格式如下：

（【*】【函数指针名称】）（【参数列表】）

 int result =  (*p_func)(1,2);
 int result2 =  (*p_func)(2,2);
 char* result4  = (*pFunction)("aa","bb");不能直接用函数指针加上参数就直接调用

#include <iostream>
#include <cstring>

using namespace std;


int add(int a , int b)
{
    printf("a+b=%d\n", a + b);
    return a + b;
}


char* function(char* p1, char* p2) {
    int i = 0;
    i = strcmp(p1,p2);//比较2个字符串是否相等
    if(0 == i){
        return p1;
    }else{
        return p2;
    }
}

int main(){  //xiaoyuzhizhen
    int* p ; //int* 变量p    // 声明一个 int 类型的指针变量 p，该指针指向一个int类型的对象
    int* p_int;  //int* 变量p_int   // 声明一个 int 类型的指针变量p_int，该指针指向一个int类型的对象
    char * cp;         // 声明一个 char 类型的指针变量 cp，该指针指向一个char类型的对象
    double* p_double; //指向double类型变量的指针 p_double
    struct Student* p_struct; //结构体类型的指针p_struct
    int** p_pointer; //指向 一个整形变量指针的指针




    int num = 97;//int 类型变量num
    int* p_num = &num;// 指针变量p_num  保存了变量num的内存地址&num

    float score = 10.00F;//float 类型的变量score
    float* p_score = &score; // 指针变量p_score 保存了变量score的内存地址&score



    int *arr0[10];    // 声明一个指针数组，该数组有10个元素，其中每个元素都是一个指向 int 类型对象的指针 【每一个元素都是指针】
    int (*arr1)[10];  // 声明一个数组指针，该指针指向一个 int 类型的一维数组


    int arr[3] = {1,2,3}; //arr是包含3个int元素的数组变量
     arr; &arr;//int类型的数组arr的内存地址arr   &arr
    int(*p_arr)[3]=&arr; //一个指向   含有3个int元素的数组arr   的指针变量 p_arr  【数组arr的指针变量p_arr】
    printf("指针变量p_arr=%p\n",p_arr); //指针变量p_arr=00A4FEF8

    // 或者这样写
    int(*p_arr2)[3];
     p_arr2=&arr;
    printf("指针变量 p_arr2 =%p\n",p_arr2); //指针变量 p_arr2 =00A4FEF4



   // 函数指针的赋值

      函数指针的定义
     int(*p_func)(int,int);  //指向返回类型为int，有2个int形参的函数的指针变量 p_func  【函数add的指针变量p_func】
      add; &add; //函数add的内存地址add 或者 &add
    //给函数指针p_func的赋值 add  方式1
    //给函数指针赋值时，可以用=&function或直接用函数名function。这是因为函数名被编译之后其实就是一个地址，所以这里两种用法没有本质的差别。因为一个函数标识符就表示了它的地址，并且赋值的时候函数不需要带圆括号.
     p_func=add;  // 指针变量p_func 指向 函数add的内存地址add
     //函数指针的调用方式
   int result =  (*p_func)(1,2); // a+b=3
    printf("result=%d\n", result); // result=3

    //给函数指针p_func的赋值&add  方式2
    p_func=&add;   // 指针变量p_func 指向 函数add的内存地址 &add
    //函数指针的调用方式
    int result2 =  (*p_func)(2,2); //a+b=4
    printf("result2=%d\n", result2); //result2=4

    //函数指针 p_funcc 的赋值&add  方式3
    int(*p_funcc)(int,int)=&add;
    //函数指针的调用方式
    int result3 =  (*p_funcc)(3,2); // a+b=5
    printf("result3=%d\n", result3); // result3=5


    函数指针的定义
    char* (*pFunction)(char* p1,char* p2);
    //给 函数指针 pFunction 的赋值 &function   方式2
    //给函数指针赋值时，可以用=&function或直接用函数名function。这是因为函数名被编译之后其实就是一个地址，所以这里两种用法没有本质的差别。因为一个函数标识符就表示了它的地址，并且赋值的时候函数不需要带圆括号.
    pFunction=&function;

    //函数指针pFunction 的调用方式
    char* result4  = (*pFunction)("aa","bb");
    printf("result4=%s\n", result4); // result4=bb



    int arrr[5] = {1,2,3,4,5};
    int* p_first = arr; //  数组名arrr作为右值的时候，就是第一个元素的地址
    int first =*p_first;
    printf("输出数组arrr第一个元素first=%d\n",first); //输出数组arrr第一个元素first=1
     p_first++;
    int second =*p_first;
    printf("输出数组arrr第二个元素second=%d\n",second); //输出数组arrr第二个元素second=2


}

(3)指针函数

指针函数定义

指针函数的落脚点是一个函数，这个函数的返回值是一个指针，与普通函数int function(int，int)类似，只是返回的数据类型不一样而已。

指针函数定义:
    _type_ *function(int, int) //函数function 返回类型是指针地址
     
    int* fun(int x)        //指针函数的定义
    int* fun(int x,int y)  //指针函数的定义

指针函数的调用

在调用指针函数时，需要一个同类型的指针来接收其函数的返回值。

int* result = fun(1);
    int* result = fun(1,2);

typedef struct _Data{
    int a;
    int b;
}Data;

//指针函数
Data* f(int a,int b){
    Data * data = new Data;
    data->a = a;
    data->b = b;
    return data;
}

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    //调用指针函数
    Data * myData = f(4,5);
    qDebug() << "f(4,5) = " << myData->a << myData->b;

    return a.exec();
}

函数指针与指针函数区别

（1）定义不同
指针函数本质是一个函数，其返回值为指针。
函数指针本质是一个指针，其指向一个函数。

(2) 写法不同
指针函数：int* fun(int x,int y);
函数指针：int (*fun)(int x,int y);  

(3) 星号* 归属不同

 指针函数的*是属于数据类型的
而函数指针的星号*是属于函数名的。 函数名带括号的就是函数指针  (*fun)()

 (4)用法不同
  函数指针的用法会更多，相对而言难度也更大，例如函数指针与回调函数

6.结构体和指针

  结构体指针有特殊的语法： -> 符号
    如果p是一个结构体指针，则可以使用 p ->【成员】 的方法访问结构体的成员

  

typedef struct
{
    char name[31];
    int age;
    float score;
}Student;

int main(void)
{
    Student stu = {"Bob" , 19, 98.0};
    Student*ps = &stu;

    ps->age = 20;
    ps->score = 99.0;
    printf("name:%s age:%d
",ps->name,ps->age);
    return 0;
}

7.深拷贝和浅拷贝

如果2个程序单元（例如2个函数）是通过拷贝 他们所共享的数据的 指针来工作的，这就是浅拷贝，因为真正要访问的数据并没有被拷贝。
    
    如果被访问的数据被拷贝了，在每个单元中都有自己的一份，对目标数据的操作相互 不受影响，则叫做深拷贝。

#include <iostream>
#include <cstring>

using namespace std;


class CopyDemo
{
public:
    int a;  //定义一个整型的数据成员
    char *str; //字符串指针  //一般结构体成员有指针 要自定义深拷贝构造函数，

   CopyDemo(int a, char * str)   //构造函数，两个参数
    {
      this->a=a;
    //  this->str=str;
    this->str = new char[1024]; //指针数组，动态的用new在堆上分配存储空间
     strcpy(this->str,str);    //拷贝过来
    }

    // C++会自动默认  帮我们实现一个浅拷贝制构造函数，浅拷贝只复制指针, 有问题使用深拷贝
    //浅拷贝
   /* CopyDemo(CopyDemo& obj){
        this->a=obj.a;
        this->str=obj.str; //这里是浅拷贝会出问题，要深拷贝
   }*/

    //一般结构体成员有指针 要自定义深拷贝构造函数，
   CopyDemo(CopyDemo& obj){
       this->a=obj.a;
      //  this->str=obj.str; //这里是浅拷贝会出问题，要深拷贝
        this->str = new char[1024]; //指针数组，动态的用new在堆上分配存储空间
      if(this->str!=0){
          strcpy(this->str,obj.str);    //如果成功，把内容深拷贝过来
      }
   }

    //析构函数
      ~CopyDemo() {
        delete str;
    }
};

int  main(){

    CopyDemo A(100,"hello");
    CopyDemo B = A;  //复制构造函数，把A的10和hello!!!复制给B
    cout <<"A.a="<< A.a << ",A.str=" <<A.str << endl; // A.a=100,A.str=hello
    cout <<"B.a="<< B.a << ",B.str=" <<B.str << endl;  //B.a=100,B.str=hello

    //修改后,发现A,B都被改变，原因就是浅拷贝，A,B指针指向同一地方，修改后都改变 所以要使用深拷贝
    B.a = 80;
    B.str = "word";
    //B.str[0] = 'k';
    cout <<"A.a="<< A.a << ",A.str=" <<A.str << endl; // A.a=100,A.str=hello
    cout <<"B.a="<< B.a << ",B.str=" <<B.str << endl;  //B.a=80,B.str=word

}