【C语言基础】指针、结构体

关注

原创最新推荐文章于 2025-10-16 20:14:41 发布 5.4k 阅读 AI 写同款· GEO 优化 ›

结构体指针详解 1、用结构体变量来为结构体指针初始化 struct student //定义了一个结构体 { long stuid; char name[10]; int age; int score; }stu1; //定义了一个结构体变量 struct student stu2; //因为结构体含有名字，所以可以继续定义结构体变量stu2 struct student *stu3; //定义了一个结构体指针 stu3=&stu1; //同指针一样，结构体. 阅读详情

指针

指针是什么？

在计算机科学中，指针（Pointer）是编程语言中的一个对象，利用地址，它的值直接指向（points to）存在电脑存储器中另一个地方的值。由于通过地址能找到所需的变量单元，可以说，地址指向该变量单元。因此，将地址形象化的称为“指针”。意思是通过它能找到以它为地址的内存单元。

1个单元的大小通常为1个字节

代码示例：

#include <stdio.h>
int main()
{
    int a = 10;//在内存中开辟一个空间
    int *p = &a;//指针变量，用来存放a的地址
    //通过解引用*取出变量a的地址
    return 0;
}

总结：指针就是变量，用来存放地址的变量。（存放在指针中的值都被当成地址处理）。

对于32位的机器，假设有32根地址线，那么假设每根地址线在寻址的是产生一个电信号正电/负电（1或者0）那么32根地址线产生的地址就会是：

00000000 00000000 00000000 00000000

00000000 00000000 00000000 00000001

...

11111111 11111111 11111111 11111111

这里就有2的32次方个地址。

同样的方法，那64位机器，如果给64根地址线，那能编址多大空间，自己计算。

此时我们就知道：

在32位的机器上，地址是32个0或者1组成二进制序列，那地址就得用4个字节的空间来存储，所以一个指针变量的大小就应该是4个字节。

那如果在64位机器上，如果有64个地址线，那一个指针变量的大小是8个字节，才能存放一个地址。

总结：

指针是用来存放地址的，地址是唯一标示一块地址空间的。
指针的大小在32位平台是4个字节，在64位平台是8个字节。

指针和指针类型

这里我们在讨论一下：指针的类型我们都知道，变量有不同的类型，整形，浮点型等。那指针有没有类型呢？准确的说：有的。

总结：

指针类型决定了指针进行引用操作的时候，能够访问空间的大小

int*p; *p能够访问4个字节

char*p; *p能够访问1个字节

double*p; *p能够访问8个字节

#include <stdio.h>
int main()
{
    int a = 0x11223344;
    int *pa = &a;
    char *pc = &a;
    printf("%p\n", pa);
    printf("%p\n", pa+1);//4个字节
    printf("%p\n", pc);
    printf("%p\n", pc+1);//1个字节
    return 0;
}

总结：指针类型决定了：指针走一步走多远（指针的步长）

int *p; p+1 --> 4

char *p; p+1 --> 1

double *p; p+1 -->8

指针的解引用：

#include <stdio.h>
int main()
{
    int arr[10] = {0};
    //int *p = arr;
    //数组名-首元素的地址
    char *p = arr;
    int i = 0;
    for(i = 0; i < 10; i++)
    {
        *(p + i) = 1;//将数组内的所有0元素更改为1
    }
    system("pause");
    return 0;
}

总结：指针的类型决定了，对指针解引用的时候有多大的权限（能操作几个字节）。

比如： char* 的指针解引用就只能访问一个字节，而 int* 的指针的解引用就能访问四个字节。

野指针

野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）

成因

1、指针未初始化

#include <stdio.h>
int main()
{
    int a;//局部变量不初始化，默认是随机值
    int *p;//局部的指针变量，也会被初始化随机值
    *p = 20;
    printf("%d\n", a);
    return 0;
}

2、指针越界访问

#include <stdio.h>
int main()
{
    int arr[10] = {0};
    int *p = arr;
    int i = 0;
    for(i = 0; i <= 11; i++)
    {
        p++;//10后面就会越界
    }
    return 0;
}

3、指针指向的空间释放

#include <stdio.h>
int *test()
{
    int a = 10;//开辟a的地址空间
    return &a;//返回p后空间会还给系统（不再属于编译器）
}
int main()
{
    int *p = test();//调用上方test函数，p接收了a的地址
    *p = 20;//指向的空间已经被释放了
    return 0;
}

如何规避野指针

指针初始化
小心指针越界
指针指向空间释放即使置NULL
指针使用之前检查有效性

#include <stdio.h>
int main()
{
    int a = 10;
    int *p = NULL; //NULL - 用来初始化指针，给指针赋值
    int *pa = &a;//初始化
    if(pa != NULL)
    {
        *pa = 20;
    }
    return 0;
}

指针运算

指针+-整数
指针-指针
指针的关系运算

指针+-整数

#include <stdio.h>
int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    int i = 0;
    int sz = sizeof(arr) / sizeof(arr[0]);
    int *p = &arr[9];
    // for(i = 0; i < sz; i++)
    // {
    //     printf("%d ", *p);
    //     p = p+1;
    //     p+=1;
    //     p++; 三种都行
    // }
    // for(i = 0; i < 5; i++)
    // {
    //     printf("%d ", *p);
    //     p+=2;
    // }
    for(i = 0; i < 5; i++)
    {
        printf("%d ", *p);
        p-=2;
    }
    return 0;
}

指针 - 指针

ep1：

int main()
{
    char ch[5] = {0};
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    printf("%d\n", &arr[9] - &arr[0]);//9
    //指针+/-指针等于中间元素个数
    //printf("%d\n", &arr[9] - &ch[0]);
    //只有当指针指向同一个空间时才可以进行+/-
    system("pause");
    return 0;
}

ep2：

int my_strlen(char *str)
{
    char *start = str;
    char *end = str;
    while(*end != '\0')
    {
        end++;
    }
    return end - start;//
}

int main()
{
    //strlen - 求字符串长度
    //递归 - 模拟实现了strlen-计数器的方式1，递归的方式2
    char arr[] = "bit";
    int len = my_strlen(arr);
    printf("%d\n", len);
    system("pause");
    return 0;
}

指针的关系运算

#include <stdio.h>
#define A 5
int main()
{
    float arr[A];
    float *p;
    for(p = &arr[A]; p > &arr[0];)
    {
        * --p = 0;
        // *p = 0; 尽量避免这样写，因为标准并不保证它可行

    }
    printf("%d\n", arr[A]);
    return 0;
}

标准规定： 允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但是不允许与指向第一个元素之前的那个内存位置的指针进行比较。

指针和数组

#include <stdio.h>
int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9,0};    
    printf("%p\n", &arr);
    printf("%p\n", &arr+1); 

    printf("\n%p\n", arr);//地址 = 首元素地址
    printf("%p\n", arr+1);

    printf("\n%p\n", &arr[0]);
    printf("%p\n", &arr[0]+1);
    return 0;
}

结果：

结论：数组名表示的是数组首元素的地址。

特殊情况：

&数组名：数组名不是首元素的地址，表示了整个数组，此时 &数组名取出的是整个数组的地址
sizeof(数组名)：数组名表示的是整个数组，sizeof(数组名)计算的是整个数组的大小

尝试用指针访问数组：

#include <stdio.h>
int main()
{
    int arr[10] = {0};
    int *p = arr;
    int i = 0;
    for(i = 0; i < 10; i++)
    {
        printf("&arr[%d] = %p   <====> p+%d = %p\n", i, &arr[i], i, p+i));
    }
    return 0;
}

结果：

由此看出： p+i 其实计算的是数组 arr 下标为i的地址。

那我们就可以直接通过指针来访问数组。

ep：

#include <stdio.h>
int main()
{
    int arr[10] = {0};
    int *p = arr;
    int i = 0;
    for(i=0; i<10; i++)
    {
        *(p+i) = i;
    }
    for(i=0; i<10; i++)
    {
        printf("%d ", arr[i]);
        //此时用*(p+i)也可以
    }
    return 0;
}

二级指针

#include <stdio.h>
int main()
{
    int a = 10;
    int *pa = &a;
    //*pa 通过对a中的地址进行解引用，这样找到的是 a ，*pa 此时访问的就是 a的地址
    int * *ppa = &pa; //ppa就是二级指针 
    //**ppa 先通过 *ppa 找到 pa ,然后对 pa 进行解引用操作，*pa ，此时找到的是 a
    ** ppa = 20;
    printf("%d\n", *pa);
    printf("%d\n", **ppa);
    printf("%d\n", a);
    //int *** pppa = &ppa;
    //三级和往上级别指针都同上
    return 0;
}

指针数组

#include <stdio.h>
int main()
{
    int a = 10;
    int b = 20;
    int c = 30;
    // int *pa = &a;
    // int *pb = &b;
    // int *pc = &c;
    //整型数组 - 存放整型
    //字符数组 - 存放字符
    //指针数组 - 存放指针
    //int arr[10];
    int *arr2[3] = {&a, &b, &c};
    int i = 0;
    for(i = 0; i < 3; i++)
    {
        printf("%d ", *(arr2[i]));
    }
    return 0;
}

结构体

结构体的声明

结构的基础知识

结构是一些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量。

结构的声明：

#include <stdio.h>
// struct Stu
// {
//     //成员变量
//     char name[20];
//     short age;
//     char phone[12];
//     char sex[4];
// }s1,s2,s3;
//s1，s2，s3是三个全局的结构体变量
typedef struct Stu
{
    //成员变量
    char name[20];
    short age;
    char phone[12];
    char sex[4];
}Stu;//类型
int main()
{
    struct Stu s1;//局部的结构体变量
    struct Stu s2;
    return 0;
}

注：struct：结构体关键字，Stu：结构体标签，struct Stu：结构体类型

结构成员的类型

结构的成员可以是标量、数组、指针，甚至是其他结构体。

结构体变量的定义和初始化

当有了结构体类型后，定义变量将会变得很简单

#include <stdio.h>
typedef struct Stu
{
    //成员变量
    char name[20];
    short age;
    char phone[12];
    char sex[4];
}Stu;//类型

int main()
{
     Stu s1 = {"张三",20,"15701984331","boy"};//局部的结构体变量
     struct Stu s2 = {"李四",18,"157130284312","girl"};
    struct Stu s2;
    return 0;
}

结构体成员的访问

结构体变量访问成员结构变量的成员是通过点操作符（.）访问的。点操作符接受两个操作数。

#include <stdio.h>
struct S//类型声明
{
    int a;
    char c;
    char arr[20];
    double d;
};

struct T//类型声明
{
    char ch[10];
    struct S s;
    char *pc;
};

int main()
{
    char arr[] = "hello bit\n";
    struct T t = {"hehe", {100 ,'w' , "hello world", 3.14}, arr};//结构体嵌套初始化
    printf("%s\n",t.ch);    //使用.访问t成员ch
    printf("%s\n",t.s.arr); //使用.访问t成员中的s，再使用.访问s中成员arr
    printf("%lf\n",t.s.d);  //使用.访问t成员中的s，再使用.访问s中成员d
    printf("%s\n", t.pc);   //使用.访问t成员中的pc
    return 0;
}

注：不同范围的类型互不影响

结构体传参

#include <stdio.h>

typedef struct Stu
{
    //成员变量
    char name[20];
    short age;
    char phone[12];
    char sex[4];
}Stu;//类型

void Print1(Stu tmp)
{
    printf("name:  %s\n", tmp.name);
    printf("age:   %s\n", tmp.age);
    printf("phone: %s\n", tmp.phone);
    printf("sex:   %s\n", tmp.sex);
}

void Print2(Stu *ps)
{
    printf("name:  %s\n", ps->name);
    printf("age:   %s\n", ps->age);
    printf("phone: %s\n", ps->phone);
    printf("sex:   %s\n", ps->sex);
}

int main()
{
    Stu s = { "小明", 40, "15701983221","boy"};
    //打印结构体数据
    Print1(s);
    Print2(&s);
    return 0;
}

问：上方代码的Print1好还是Print2好？

答：首选是Print2。（无论如何只根据使用操作平台 32位/64位传址过去 4/8 个字节的空间）

由于函数传参的时候，参数是需要压栈的。如果传递一个结构体对象的时候，结构体过大，参数压栈的的系统开销比较大，所以会导致性能的下降。

结论：结构体传参的时候，要传结构体的地址。

收录于