[C语言]初阶指针和结构体

EnticE152

已于 2023-07-19 20:00:02 修改

阅读量1.9k

点赞数 39

文章标签： c++ 开发语言 c语言

于 2022-10-02 19:07:36 首次发布

本文链接：https://blog.csdn.net/qq_66767938/article/details/127133116

版权

初阶指针和结构体：：

指针

1.指针概述

内存

内存含义：

存储器：计算机的组成中，用来存储程序和数据，辅助CPU进行运算处理的重要部分。

内存：内部存储器，暂存程序/数据——掉电丢失 SRAM,DRAM,DDR,DDR2,DDR3。

外存：外部存储器。长时间保存程序/数据——掉电不丢失ROM，ERRROM，FLASH(NAND,NOR),硬盘，光盘。

内存是沟通CPU与硬盘的桥梁：

1.暂存CPU中的运算数据 2.暂存与硬盘等外部存储器交换的数据。

物理存储器和存储地址空间

有关内存的两个概念：物理存储器和存储地址空间。

物理存储器：实际存在的具体存储器芯片。

1.主板上装插的内存条 2.显示卡上显示的RAM芯片 3.各种适配卡上的RAM芯片和ROM芯片

存储地址空间：简单来说就是对存储器编码的范围。我们在软件上常说的内存就是指这一层含义

1.编码：对每个物理存储单元(一个字节)分配一个号码

2.寻址：可以根据分配的号码找到相应的存储单元，完成数据的读写

内存地址

1.将内存抽象成一个很大的一堆字符数组。

2.编码就是对内存的每一个字节分配一个32位或64位的编号(与32位或者64位处理器相关)。

3.这个内存编号我们称之为内存地址：

char：占一个字节分配一个地址 int：占4个字节分配4个地址 float,struct,函数,数组同理

指针和指针变量

内存区的每一个字节都有一个编号，这就是地址。如果在程序中定义了一个变量，在对程序进行编译或运行时，系统就会给这个变量分配内存单元，并确定它的内存地址(编号)。指针的实质就是内存地址，指针是内存单元的编号，指针变量就是存放地址的变量。

通常我们叙述时会把指针变量简称为指针。

2.指针基础知识

指针变量的定义和使用

1.指针是一种数据类型，指针变量是一种变量

2.指针变量指向谁，就把谁的地址赋值给该指针变量

3.” * “操作符操作的是指针变量指向的内存空间

总之：指针是内存中最小单元的编号，也就是地址。平时口语中说的指针，通常指的就是指针变量，是用来存放内存地址的变量。即指针就是地址，口语中的指针通常指的就是指针变量。

#include <stdio.h>

int main()
{
	int a = 0;
	char b = 100;
	printf("%p, %p\n", &a, &b); //打印a, b的地址

	//int*代表一种数据类型，int*指针类型，p才是变量名
	//定义了一个指针类型的变量，可以指向一个int类型变量的地址
	int *p;
	p = &a;//将a的地址赋值给变量p，p也是一个变量，值是一个内存地址编号
	printf("%d\n", *p);//p指向了a的地址，*p就是a的值

	char *p1 = &b;
	printf("%c\n", *p1);//*p1指向了b的地址，*p1就是b的值

	return 0;
}

注意：&可以取得一个变量在内存中的地址。但是，不能取寄存器变量，因为寄存器变量不在内存里而在CPU里，所以是没有地址的。

通过指针间接修改变量的值

int main()
{
	int a = 0;
	int b = 11;
	int* p = &a;

	*p = 100;
	printf("a = %d, *p = %d\n", a, *p);

	p = &b;
	*p = 22;
	printf("b = %d, *p = %d\n", b, *p);

	return 0;
}

指针大小

指针变量是用来存放地址的变量(存放在指针的值都被当成地址处理)

那么就出现两个问题：1.一个小的单元到底是多大？(一个字节) 2.如何编址？

经过仔细的计算和权衡我们发现一个字节给一个对应的地址是比较合适的。对于32位的机器，假设有32根地址线，那么假设每根地址线在寻址的时候产生高电平(高电压)和低电平(低电压)就是1或者0.

那么32根地址线产生的地址就会是：

这里就有2的32次方个地址。每个地址标识一个字节，那我们就可以给(2^32byte == 2^32/1024KB == 2^32/1024/1024MB == 2^32/1024/1024/1024GB == 4GB)4G的空间进行编址。同样的方法，64位机器也可计算求得。

这里我们就明白：

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

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

总之：

1.指针是用来存放地址的，地址是唯一标示一块地址空间的，即一个无符号的十六进制整型数。

2.指针的大小在32位平台是4个字节，在64位平台是8个字节。

指针类型不能混用的原因：

结论1：指针类型决定了指针在被解引用的时候访问几个字节，如果是int*的指针，解引用访问4个字节，如果是char*的指针，解引用访问1个字节。所以，指针类型的不同在存放时不会产生问题，但不同的指针类型大小决定了解引用时访问几个字节。

结论2：指针的类型决定了指针+-1操作的时候，跳过几个字节，即决定了步长。

int* 和 float* 指针不能混用的原因：

虽然二者访问的变量大小都是4个字节，但int* 访问的是整型数据，是以整型的存储方式存储在内存中的，float* 访问的是浮点型数据，是以浮点型的数据存储在内存中的。

3.野指针和空指针

野指针和空指针的定义

野指针的定义是指针变量指向一个未知的空间，指针变量也是变量，是变量就可以任意赋值，不要越界即可(32位为4字节，64位为8字节)，但是任意数值赋值给指针变量没有意义，因为这样的指针就成了野指针，此指针指向的区域是不可控的(操作系统不允许操作此指针指向的内存区域)。所以，野指针不会直接引发错误，即野指针不解引用是不会造成危险的，操作野指针指向的内存区域才会出问题。但是野指针和有效指针变量保存的都是数值，为了标志此指针变量没有指向任何变量(空闲可用)，C语言中可以把NULL赋值给此指针，空指针是指内存地址编号为0的空间。

注：操作系统将0-255作为系统占用，不允许访问操作，因此不建议将一个变量的值直接赋值给指针变量。

int main()
{
	int a = 100;
	int* p;
	p = a; //把a的值赋值给指针变量p，p为野指针， ok，不会有问题，但没有意义

	p = 0x12345678; //给指针变量p赋值，p为野指针， ok，不会有问题，但没有意义

	*p = 1000;  //操作野指针指向未知区域，内存出问题，err
	return 0;
}

野指针成因

1.指针未初始化 2.指针越界访问 3.指针指向的空间释放

#include <stdio.h>
int main()
{ 
    int *p;//局部变量指针未初始化，默认为随机值
    *p = 20;
    return 0; 
}
#include <stdio.h>
int main()
{
    int arr[10] = {0};
    int *p = arr;
    int i = 0;
    for(i=0; i<=11; i++)
    {
         //当指针指向的范围超出数组arr的范围时，p就是野指针
         *p++ = i;
    }
    return 0;
}
#include<stdio.h>
int* test()
{
	int a = 10;
    return &a;
}
int main()
{
    int*p = test();
    return 0;
}
//因此函数返回时不可以函数局部变量的地址

如何规避野指针

1.指针初始化 2.小心指针越界 3.指针指向空间释放即时置为NULL 4.避免返回局部变量的地址

5.指针使用之前检查有效性

#include <stdio.h>
//使用之前检查指针有效性
int main()
{
    int *p = NULL;
    int a = 10;
    p = &a;
    if(p != NULL)
   {
        *p = 20;
   }
    return 0; 
}

4.万能指针与const修饰的指针变量

万能指针

void*指针可以指向任意变量的内存空间：在内存中 void*占四个字节大小，因此万能指针可以接收任意类型变量的内存地址，但最好将其强制转换为void*,也可以通过万能指针修改变量的值，但是修改变量的值时需要找到变量对应的指针类型。

int main()
{
	int a = 10;
	void* p = NULL;
	p = (void*)&a; //指向变量时，最好转换为void *
	//使用指针变量修改变量值时，转换为int *
	*((int*)p) = 11;
	printf("a = %d\n", a);
	return 0;
}

const修饰指针变量

1.const修饰普通变量变为常量：可以通过指针间接修改常量的值

2.const修饰指针类型：可以修改指针变量的值，但不可以修改指针变量指向内存空间的值

3.const修饰指针变量：可以修改指针变量指向内存空间的值，不可以修改指针变量的值

4.const修饰指针类型修饰指针变量：只读指针只能通过二级指针来修改

int main()
{
	int a = 100;
	int b = 200;

	//指向常量的指针
	//修饰*，指针指向内存区域不能修改，指针变量可以改
	const int* p1 = &a; //等价于int const *p1 = &a;
	*p1 = 111; //err
	p1 = &b; //ok

	//指针常量
	//修饰p1，指针变量不能改，指针指向的内存区域可以修改
	int* const p2 = &a;
	p2 = &b; //err
	*p2 = 222; //ok
	//通过二级指针来改变只读指针的值
	const int* const p = &a;
	int** pp = &p;
	*pp = &b;
	return 0;
}

在编辑程序时，指针作为函数参数，如果不能修改指针对应内存空间的值，需要使用const修饰指针数据类型。

5.指针运算

指针+-整数

如果是一个int*,+1的结果是增加一个int的大小。

如果是一个char*,+1的结果是增加一个char的大小。

#include <stdio.h>
int main()
{
	int n = 10;
	char* pc = (char*)&n;
	int* pi = &n;
	printf("%p\n", &n);
	printf("%p\n", pc);
	printf("%p\n", pc + 1);
	printf("%p\n", pi);
	printf("%p\n", pi + 1);
	return 0;
}
int main()
{
	int a = 0;
	int *p = &a;
	printf("%p\n", p);
	p += 2;//移动了2个int
	printf("%p\n", p);

	char b = 0;
	char *p1 = &b;
	printf("%p\n", p1);
	p1 += 2;//移动了2个char
	printf("%p\n", p1);
	return 0;
}
int main()
{
	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);

	int *p = arr;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *p);
		p++;
	}
	return 0;
}
int main()
{
	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);

	int *p = arr+sz-1;
    for (i = 0; i < sz; i++)
	{
		printf("%d ", *p);
		p--;
	}
	printf("\n");

	return 0;
}
int main()
{
	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	int *p2 = &arr[2]; //第2个元素地址
	int *p1 = &arr[1]; //第1个元素地址
	printf("p1 = %p, p2 = %p\n", p1, p2);

	int n1 = p2 - p1; //n1 = 1
	int n2 = (int)p2 - (int)p1; //第二个元素和第一个元素在内存之间相差4byte n2=4
	printf("n1 = %d, n2 = %d\n", n1, n2);	
	return 0;
}
#define N_VALUES 5
int main()
{
	float values[N_VALUES];
	float* vp;
	//指针+-整数；指针的关系运算
	for (vp = &values[0]; vp < &values[N_VALUES];)
	{
		*vp++ = 0;
	}
	return 0;
}

指针-指针

指针-指针得到的是内存中指针和指针之间的元素个数，但不是所有的指针都能相减，指向同一块空间的两个指针才能相减。

//指针-指针模拟实现strlen
int my_strlen(char* str)
{
    char* start = str;
	while (*str != '\0')
    {
	    str++;
    }
    return (str - start);
}
int main()
{
	int len = my_strlen("abcdef");
	printf("%d\n", len);
	return 0;
}

指针的关系运算

#define values[N_VALUES] 5
float values[N_VALUES];
float* vp;
for(vp = &values[N_VALUES]; vp > &values[0];)
{
    *--vp = 0;
}
//将代码修改如下：
for(vp = &values[N_VALUES-1]; vp >= &values[0];vp--)
{
    *vp = 0;
}

实际在绝大多数的编译器上是可以顺利完成任务的，然而我们还是应该避免这样写，因为标准并不保证它可行。

标准规定：

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

6.指针和数组

结论:数组名表示的是数组首元素的地址。既然可以把数组名当成地址存放到一个指针中，我们使用指针来访问数据就成为可能。例如：

#include <stdio.h>
int main()
{
    int arr[] = {1,2,3,4,5,6,7,8,9,0};
    int i = 0;
    int* p = arr; //指针存放数组首元素的地址
    int sz = sizeof(arr)/sizeof(arr[0]);
    for(i=0; i<sz; i++)
    {
         printf("&arr[%d] = %p <====> p+%d = %p\n", i, &arr[i], i, p+i);
    }
    return 0; 
}

运行结果如下：

所以p+i其实计算的是数组arr下标为 i 的地址.

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

int main()
{
     int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
     int *p = arr; //指针存放数组首元素的地址
     int sz = sizeof(arr) / sizeof(arr[0]);
     int i = 0;
     for (i = 0; i < sz; i++)
     {
         printf("%d ",*(p+i));
     }
     return 0;
}

7.二级指针

一级指针用来存放变量的地址，二级指针则用来存放一级指针变量的地址

一级指针+偏移量相当于跳过了偏移量个元素，二级指针+偏移量相当于跳过了偏移量个一级指针的大小

二级指针的运算：

1.*ppa通过对ppa的地址进行解引用，这样找到的是pa，*ppa其实访问的就是pa.

2.**ppa先通过*ppa找到pa，然后对pa进行解引用操作，那找到的就是a.

int b = 20; *ppa = &b;//等价于 pa = &b;
**ppa = 30;
//等价于*pa = 30;
//等价于a = 30;

8.指针数组

指针数组，它是数组，是存放指针的数组，数组的每个元素都是指针类型。

指针数组的应用实例：

//打印二维数组
int main()
{
    int arr[3][4] = { 1,2,3,4,2,3,4,5,3,4,5,6 };
    int i = 0;
	int j = 0;
    for (i = 0; i < 3; i++)
    {
    	for (j = 0; j < 4; j++)
        {
    		printf("%d ", arr[i][j]);
        }
    	printf("\n");
    }
    return 0;
}
//指针数组模拟二维数组
int main()
{
    int arr1[4] = { 1,2,3,4 };
    int arr2[4] = { 2,3,4,5 };
	int arr3[4] = { 3,4,5,6 };

	int* parr[3] = {arr1, arr2, arr3};
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 4; j++)
		{
			printf("%d ", parr[i][j]);
		}
		printf("\n");
	}

	return 0;
}

9.指针和函数

函数形参是否会改变实参的值

值传递：形参不影响实参的值

地址传递：形参可以改变实参的值

#include <stdio.h>

void swap1(int x, int y)
{
	int temp = 0;;
	temp = x;
	x = y;
	y = temp;
}

void swap2(int* x, int* y)
{
	int temp = 0;
	temp = *x;
	*x = *y;
	*y = temp;
}
int main()
{
	int a = 3;
	int b = 5;
	swap1(a, b); //值传递
	printf("a = %d, b = %d\n", a, b);

	a = 3;
	b = 5;
	swap2(&a, &b); //地址传递
	printf("a2 = %d, b2 = %d\n", a, b);

	return 0;
}

数组名作为函数参数
数组名作为函数参数，函数的形参会退化为指针

#include <stdio.h>

void printArrary(int* arr, int n)
{
	int i = 0;
	for (i = 0; i < n; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}

int main()
{
	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	int n = sizeof(arr) / sizeof(arr[0]);

	//数组名做函数参数
	printArrary(arr, n); 
	return 0;
}

指针作为函数的返回值

#include <stdio.h>

int a = 10;
int* getA()
{
	return &a;
}
int main()
{
	*( getA() ) = 111;
	printf("a = %d\n", a);
	return 0;
}

10.指针和字符串

字符指针

#include <stdio.h>

int main()
{
	char str[] = "hello world";//栈区字符串 可修改
	char* p = str;
	*p = 'm';
	p++;
	*p = 'i';
	printf("%s\n", str);

	p = "mike jiang";
	printf("%s\n", p);
	char* q = "test";//数据区常量字符串 不可修改
	printf("%s\n", q);
	return 0;
}

字符指针作为函数参数

#include <stdio.h>
//字符串追加
void my_strcat(char *dest, const char *src)
{
	int len1 = 0;
	int len2 = 0;
	while (dest[len1])
	{
		len1++;
	}
    while (src[len2])
	{
		len2++;
	}
	int i = 0;
	for (i = 0; i < len2; i++)
	{
		dest[len1 + i] = src[i];
	}
}

int main()
{
	char dst[100] = "hello mike";
	char src[] = "123456";
	my_strcat(dst, src);
	printf("dst = %s\n", dst);
	return 0;
}

指针数组作为main函数的形参

int main(int argc,char* argv[])

1.main函数是操作系统调用的，第一个参数标明argc数组的成员数量，argv数组的每个成员都是char* 类型.

2.argv是命令行参数的字符串数组.

3,argc代表命令行参数的数量，程序名字本身算一个参数.

#include <stdio.h>

//argc: 传参数的个数（包含可执行程序）
//argv：指针数组，指向输入的参数
int main(int argc, char *argv[])
{

	//指针数组，它是数组，每个元素都是指针
	char *a[] = { "aaaaaaa", "bbbbbbbbbb", "ccccccc" };
	int i = 0;

	printf("argc = %d\n", argc);
	for (i = 0; i < argc; i++)
	{
		printf("%s\n", argv[i]);
	}
	return 0;
}

结构体

1.结构体类型的声明

1.结构的基础知识：

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

2.结构的声明：

typedef struct Stu
{
    char name[20];//名字
    int age;//年龄
    char sex[5];//性别
    char id[20];//学号
}Stu；//分号不能丢

3.结构成员的类型

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

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

struct Peo
{
	char name[20];
    char tele[12];
	char sex[5];
	int high;
};

struct St
{
	struct Peo p;//结构体嵌套结构体
	int num;
	float f;
};
int main()
{
	struct Peo p1 = {"张三", "15596668862", "男", 181};//结构体变量的创建
	struct St s = { {"李四", "15596668888", "女", 166}, 100, 3.14f};
	printf("%s %s %s %d\n", p1.name, p1.tele, p1.sex, p1.high);
	printf("%s %s %s %d %d %f\n", s.p.name, s.p.tele, s.p.sex, s.p.high, s.num, s.f);
	return 0;
}

2.结构体初始化

结构体变量访问成员是通过点操作符( . )访问的，点操作符接受两个操作数.

//代码1
struct S s;
strcpy(s.name, "zhangsan");//使用.访问name成员
s.age = 20;//使用.访问age成员
//代码2
struct Stu
{
    char name[20];
    int age;
};
void print(struct Stu* ps)
{
    printf("name = %s age = %d\n", (*ps).name, (*ps).age);
    //使用结构体指针访问指向对象的成员
    printf("name = %s age = %d\n", ps->name, ps->age);
}
int main()
{
    struct Stu s = {"zhangsan", 20};
    print(&s);//结构体地址传参
    return 0; 
}

3.结构体传参

struct Peo
{
	char name[20];
	char tele[12];
    char sex[5];
	int high;
};
struct St
{
	struct Peo p;
	int num;
	float f;
};
void print1(struct Peo p)
{
	printf("%s %s %s %d\n", p.name, p.tele, p.sex, p.high);//结构体变量.成员变量
}
void print2(struct Peo* sp)
{
	printf("%s %s %s %d\n", sp->name, sp->tele, sp->sex, sp->high);//结构体指针->成员变量
}
int main()
{
    struct Peo p1 = {"张三", "15596668862", "男", 181};//结构体变量的创建
	struct St s = { {"lisi", "15596668888", "女", 166}, 100, 3.14f};
	printf("%s %s %s %d\n", p1.name, p1.tele, p1.sex, p1.high);
	printf("%s %s %s %d %d %f\n", s.p.name, s.p.tele, s.p.sex, s.p.high, s.num, s.f);
	print1(p1);
	print2(&p1);
	return 0;
}

上面的print1和print2函数哪个好些？

答：优选print2函数.

原因：函数传参的时候参数是需要压栈的，如果传递一个结构体对象的时候，结构体过大，参数压栈的系统开销过大，会导致性能的下降.

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