C语言--指针详解

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

/* 方法1：使指针指向现有的内存 */
int x = 1;
int *p = &x;　　// 指针 p 被初始化，指向变量 x ，其中取地址符 & 用于产生操作数内存地址

/* 方法2：动态分配内存给指针 */
int *p;
p = (int *)malloc(sizeof(int) * 10);　　　　// malloc 函数用于动态分配内存
free(p);　　　　// free 函数用于释放一块已经分配的内存，常与 malloc 函数一起使用，要使用这两个函数需要头文件 stdlib.h

#include "stdio.h"

int main(){
    int *p;
    *p = 1;
    printf("%dn",*p);

    return 0;  
}

#include "stdio.h"

int main(){
    int x = 1;  
    int *p = &x;
    printf("%dn",*p);
　  *p = 2;
    printf("%dn",*p);

    return 0;  
}

#include "stdio.h"

int main(){
    int *p = NULL;
    printf("p的地址为%dn",p);

    return 0;
}

/***************
 * 程序输出：
 * p的地址为0
***************/

#include "stdio.h"

int main(){
    int a[10] = {1,2,3,4,5,6,7,8,9,0};
    int sub;
    int *p1 = &a[2];
    int *p2 = &a[8];

    sub = p2-p1;                                                                            
    printf("%dn",sub);　　　　// 输出结果为 6

    return 0;
}

int a[10];        // 声明一个int类型的数组，这个数组有10个元素

int *p;           // 声明一个int类型的指针变量

p = &a[0];        // 对指针进行初始化，p将指向数组 a 的第 1 个元素 a[0]

p = a;        // a 为数组名，代表该数组最开始的一个元素的地址 

#include "stdio.h"                                                                          
 
int main(){
    int x[10] = {1,2,3,4,5,6,7,8,9,0};
    int *p = x;
    printf("x的地址为：%pn",x);
    printf("x[0]的地址为：%pn",&x[0]);
    printf("p的地址为：%pn",&p);　　　　　　// 打印指针 p 的地址，并不是指针所指向的地方的地址

    p += 2;
    printf("*(p+2)的值为：%dn",*p);　　　　// 输出结果为 3，*(p+2)指向了 x[2]

    return 0;
}

int *p[10];    // 声明一个指针数组，该数组有10个元素，其中每个元素都是一个指向int类型的指针

int (*p)[10];        // 声明一个数组指针 p ，该指针指向一个数组

 #include "stdio.h"
 
 int main(){
     int arr[2][3] = {1,2,3,4,5,6};               // 定义一个二维数组并初始化
     int (*p)[3];                                 // 定义一个数组指针，指针指向一个含有3个元素的一维数组
 
     p = arr;                                     // 将二维数组的首地址赋给 p，此时 p 指向 arr[0] 或 &arr[0][0]
     printf("%dn",(*p)[0]);　　　　　　　　　　　　  // 输出结果为 1
     p++;　　　　　　　　　　　　　　　　　　　　　　　　 // 对 p 进行算术运算，此时 p 将指向二维数组的下一行的首地址，即 &arr[1][0]
     printf("%dn",(*p)[1]);                      // 输出结果为5
 
     return 0;                                                                               
 } 

struct message{　　　　　　      // 声明一个结构 message
    char name[10];             // 成员
    int age;
    int score;  
};

typedef struct message s_message;　　　　 // 类型定义符 typedef

s_message mess = {"tongye",23,83};　　　　// 声明一个 struct message 类型的变量 mess,并对其进行初始化　

--------------------------------------------------------------------------------------------------------------
/* 另一种更简便的声明方法 */
typedef struct{
　　char name[10];
　　int age;
　　int score;
}message;

#include "stdio.h"

int main(){
　　printf("%sn",mess.name);　　　　// 输出结果：tongye
　　printf("%dn",mess.age);　　　　 // 输出结果：23

　　return 0;
}

s_message *p;        // 声明一个结构指针 p ，该指针指向一个 s_message 类型的结构
*p = &mess;　　　　　　// 对结构指针的初始化与普通指针一样，也是使用取地址符 &

#include "stdio.h"

typedef struct{
    char name[10];
    int age;
    int score;  
}message;

int main(){
    message mess = {"tongye",23,83};
    message *p = &mess;

    printf("%sn",p->mess);　　　　　　// 输出结果为：tongye
    printf("%dn",p->score);         // 输出结果为：83

    return 0;
} 

#include "stdio.h"

void swap1(int a,int b)　　　　　　  // 参数为普通的 int 变量
{
　　int temp;
　　temp = a;
　　a = b;
　　b = temp;
}

void swap2(int *a,int *b)　　　　　　// 参数为指针，接受调用函数传递过来的变量地址作为参数，对所指地址处的内容进行操作
{
　　int temp;　　　　                // 最终结果是，地址本身并没有改变，但是这一地址所对应的内存段中的内容发生了变化，即x,y的值发生了变化
　　temp = *a;
　　*a = *b;
　　*b = temp;
}

int main()
{
　　int x = 1,y = 2;
　　swap1(x,y);                     // 将 x,y 的值本身作为参数传递给了被调函数
　　printf("%d %5dn",x,y);         // 输出结果为：1     2

　　swap(&x,&y);                    // 将 x,y 的地址作为参数传递给了被调函数，传递过去的也是一个值，与传值调用不冲突
　　printf("%d %5dn",x,y);         // 输出结果为：2     1
　　return 0;
}

返回值类型 （* 指针变量名）（[形参列表]）;

int (*pointer)(int *,int *);        // 声明一个函数指针

#include "stdio.h"
#include "string.h"

int str_comp(const char *m,const char *n);                             // 声明一个函数 str_comp，该函数有两个 const char 类型的指针，函数的返回值为 int 类型
void comp(char *a,char *b,int (*prr)(const char *,const char*));       // 声明一个函数 comp ,注意该函数的第三个参数，是一个函数指针

int main()
{
    char str1[20];      // 声明一个字符数组
    char str2[20];
    int (*p)(const char *,const char *) = str_comp;　　　　　　　　　　　 // 声明并初始化一个函数指针，该指针所指向的函数有两个 const char 类型的指针，且返回值为 int 类型
    gets(str1);         // 使用 gets() 函数从 I/O 读取一行字符串
    gets(str2);
    comp(str1,str2,p);  // 函数指针 p 作为参数传给 comp 函数

    return 0;
}

int str_comp(const char *m,const char *n)
{
　　 // 库函数 strcmp 用于比较两个字符串，其原型是： int strcmp(const char *s1,const char *s2);
    if(strcmp(m,n) == 0) 
        return 0;
    else
        return 1;
}

/* 函数 comp 接受一个函数指针作为它的第三个参数 */
void comp(char *a,char *b,int (*prr)(const char *,const char*))
{
    if((*prr)(a,b) == 0)
        printf("str1 = str2n");
    else
        printf("str1 != str2n");
} 

int *p(void *,void*);