指针使用汇总

#include <iostream>

int main()
{
    char* a[10];   //a是一个数组，数组里面每个元素是一个char*类型的指针
    char* (*b)[10];//b是一个指针，该指针指向一个数组，数组里面每个元素是一个char*类型的指针
    char** c[10];  //c是一个数组，数组里面每个元素是一个char**类型的指针（也就是指向指针的指针）
    char (**d)[10];//d是一个指针，该指针指向一个数组指针

    int k1 = sizeof(a);//40
    int k2 = sizeof(*a);//4
    int k3 = sizeof(b);//4
    int k4 = sizeof(*b);//40
    int k5 = sizeof(c);//40
    int k6 = sizeof(*c);//4
    int k7 = sizeof(d);//4
    int k8 = sizeof(*d);//4

    system("pause");
    return 0;
}

#include <iostream>  
#include <stdio.h>   

void f(int p[3][4])   //原始类型
//void f(int p[][4])  //省略第一维长度
//void f(int (*p)[4]) //指针 指向一个数组，数组中的每个元素是int类型 
//void f(int **p) //error 不能将第二维退化为指针
{
    for (int i=0;i<3;i++)  
    {  
        for (int j=0;j<4;j++)  
            std::cout << (*(p+i))[j] << std::endl;//和p[i][j]的输出是一样的  
    }  
}

void g(char *p[3]) //原始类型
//void g(char *p[])  //省略第一维长度
//void g(char **p)   //将第一维退化为指针形式
{
    for (int i=0; i<3; ++i)
    {
        std::cout << p[i] << std::endl;
    }
}

int main()  
{   
    int c[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};   
    f(c);

    char *p[3] = {"abc", "def", "ghi"};
    g(p);

    int p1[3]; 
    int p2[3][3];
    int (*p3)[3];
    
    //p2 = &p1; //error
    p3 = &p1;   //ok
    p3 = p2;    //ok

    system( "pause" );  
    return 0;  
}  

#include <iostream>
#include<stdio.h> 

int main()
{ 
    int c[3][4]={1,2,3,4,5,6,7,8,9,10,11,12}; 

    int (&p)[3][4] = c;

    for (int i=0;i<3;i++)
    {
        for (int j=0;j<4;j++)
            std::cout << (*(p+i))[j] << std::endl;//和p[i][j]的输出是一样的
    }

    system( "pause" );
    return 0;
}

#include <iostream>

int main()  
{   
    int c[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};

    std::cout << "================" << std::endl;
    for (int i=0; i<12; i++)
        std::cout << *(*(c+i/4) +i%4)   << std::endl;

    std::cout << "================" << std::endl;
    int d[2][3][4]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24};
    for (int i=0; i<24; i++)
        std::cout << *(*(*(d+i/12)+i/4%3)+i%4)  << std::endl;

    std::cout << "================" << std::endl;
    std::cout << &c    << std::endl;   //数组首地址，          +1的单位是数组
    std::cout << c     << std::endl;   //第0行元素的地址       +1的单位是行
    std::cout << *c    << std::endl;   //第0行第0个元素的地址  +1的单位是元素
    std::cout << **c   << std::endl;   //第0个元素的值
    std::cout << *c[0] << std::endl;   //第0个元素的值

    std::cout << "================" << std::endl;
    std::cout << &c + 1 << std::endl; //数组的下一个地址，最后一个元素地址+1
    std::cout << c+1    << std::endl; //第1行首元素的地址
    std::cout << *c+1   << std::endl; //第0行第一元素的地址

    system( "pause" );  
    return 0;  
} 

#include <iostream>

int main()  
{   
    char* p1[3] = {"aaa", "bbb", "ccc"};
    char* p2[3] = {"bbb", "ccc", "ggg"};
    char* p3[3] = {"aaa", "eee", "fff"};
    char* p4[3] = {"aaa", "eee", "fff"};

    char** p[4] = {p1,p2,p3,p4}; //本身是一个数组，数组的每个元素是一个char**类型的指针

    for (int i=0;i<4;i++)//4个元素
    {
        std::cout << "================" << std::endl;
        char** q = p[i];
        for (int j=0; j<3; j++)
            std::cout << q[j] << std::endl;//p[i][j]
    }

    system( "pause" );  
    return 0;  
} 

#include <iostream>

int main() 
{ 
    typedef int (*PF1)();
    PF1 (*pf1)[10];
    int (* (*gf1)[10])(); //gf1是一个指针，指针指向一个数组，数组有10个元素，每个元素是一个函数指针，该函数不带参数，返回int
    //pf1 = gf1; 

    typedef int (*PF2)();
    PF2 pf2[10];
    int (*gf2[10])(); //gf2是一个数组，数组有10个元素，每个元素是一个函数指针，该函数不带参数，返回int
    //pf2 = gf2; //两个数组是相等的，但是不能对数组直接进行=号运算

    //int f()[];  //error 函数的返回值不能是数组
    //int f[]();  //error 数组元素类型不能是函数 

    system("pause");
    return 0;
}