C基础梳理 2019.1.2（数组首元素指针类型和数组首元素指针类型、结构体嵌套一级指针）

最新推荐文章于 2023-02-11 11:58:07 发布
最新推荐文章于 2023-02-11 11:58:07 发布
阅读量269 收藏 2
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29996285/article/details/85572576
版权

指针和数组等价吗？

数组名并不完全是一个指向数组首地址的指针。

 

数组名在编译器中常被定义为一个常量指针，数组名不被看成是指针常量是情况有以下两种：

1、数组名作为sizeof操作符的操作数时，此时sizeof返回的是整个数组的长度，而不是数组指针的长度。

2、数组名作为&操作符的操作数时，返回的是一个指向数组的指针（该指针的步长为整个数组的大小，他是一个数组指针类型），而不是指向某个数组元素的指针常量。

#include<stdio.h>
#include<stdlib.h>

void test() {
	int arr[] = { 1,2,3,4 ,5,6,7,8,9};
	printf("&arr%d   &arr+1%d\n", &arr, &arr + 1);
}
int main() {
	test();
	return 0;
}

运行结果：

 

 

数组首元素指针类型和数组首元素指针类型

数组指针类型——该指针的步长为整个数组的大小

数组首元素指针类型——该指针的步长为一个数组元素的大小

 

 

如何定义一个可以指向数组的指针

 

方法一：先定义数组类型，在定义数组指针类型

//加个括号是为了表示这是一个数组名
typedef int (ARRAY_TYPE)[5];
ARRAY_TYPE myarray;//等价于int myarray[5]

此时，这两个就是等价的了

//数组名取地址代表指向整个数组的指针
ARRAY_TYPE *pArray = &myarray;

 

对于指向数组的指针（因为他指向的是整个数组）进行解引用，该指针就退化成指向首元素的指针了。

#include<stdio.h>
#include<stdlib.h>

void test() {
	int arr[5] = { 1,2,3,4  };

	//加个括号是为了表示这是一个数组名
	typedef int(ARRAY_TYPE)[5];
	ARRAY_TYPE myarray;//等价于int myarray[5]

	ARRAY_TYPE *pArray = &myarray;
	pArray = &arr;

	printf("*(*pArray+1):%d\n", *(*pArray + 1));
}
int main() {
	test();
	return 0;
}

运行结果

 

 

方法二：直接定义数组指针类型

int arr[5] = { 1,2,3,4  };
typedef int(*ARRAY_POINTER)[5];
ARRAY_POINTER pArr = &arr;

 

 

方法三：直接定义数组指针变量

int arr[5] = { 1,2,3,4  };
int(*pArrParam)[5] = &arr;

 

 

 

二维数组名

对于二维数组同一位数组一样，除了sizeof和对数组名取地址之外，那么数组名就是指向数组首元素的常指针。

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

void test() {
	int arr[5] = { 1,2,3,4  };
	printf("%s\n", typeid(arr).name());

}
int main() {
	test();
	return 0;
}

运行结果

 

 

下图中的方法可以获取数组中的 8  

 

 

 

 

指针数组的选择排序

遍历数组，选择最小的值放在最前面的位置，然后遍历最前面的位置之后的那段数组。（每一轮固定一个值的位置）

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

void SelectSort(char **arr, int len) {
	int min = 0;
	char *temp = NULL;
	for (int i = 0; i < len; ++i) {
		min = i;
		for (int j = i + 1; j < len; ++j) {
			if (strcmp(arr[j], arr[min]) < 0) {
				min = j;
			}
		}
		if (min != i) {
			temp = arr[min];
			arr[min] = arr[i];
			arr[i] = temp;
		}
	}
}

void PrintArray(char **arr, int len){
	for(int i=0; i<len; ++i){
		printf("%s\n",arr[i]);
	}
}

void test() {
	char * arr[] = { "ddddd","aaaaa","ccccc","bbbbb" };
	int len = sizeof(arr) / sizeof(char*);
	SelectSort(arr, len);
	PrintArray(arr,len);
}

int main() {
	test();
	return 0;
}

运行结果

 

 

 

结构体

定义结构体时，不要直接给成员变量复制，结构体制是一个类型，编译器还没有为其分配空间，只有根据其类型定义变量时，才分配空间，有空间后才能赋值。

 

结构体变量的定义

下面的结构体由于没有名字，所以不能通过他再去定义新的对象了。

struct {
	int val;
}Obama;//定义类型同时定义变量

 

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

struct Person{
	char name[64];
}Obama;

void test() {
	//对象指针用 ->   对象实体用 .
	strcpy(Obama.name, "lili");
	printf("name:%s\n",Obama.name);
}
int main() {
	test();
	return 0;
}

运行结果

 

 

结构体初始化

单个结构体

栈上初始化

struct Person{
	char name[64];
}Obama;

void test() {
	struct Person person = { "lili" };	
}

 

堆上初始化

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

struct Person{
	char name[64];
}Obama;

void test() {
	struct Person *person = malloc(sizeof(struct Person));	
	strcpy(person->name, "lili");
	printf("Namw:%s", person->name);
}
int main() {
	test();
	return 0;
}

运行结果

 

多个结构体变量

栈上初始化

struct Person{
	char name[64];
};

void test() {
	//聚合初始化
	struct Person person[] = {
		{"aaa"},
		{"bbb"},
		{"ccc"}
	}
}

 

堆上初始化

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

struct Person{
	char name[64];
};

void test() {
	struct Person *person = malloc(sizeof(struct Person) * 6);
	for (int i = 0; i < 6; ++i) {
		sprintf(person[i].name, "lili");
		printf("name:%s\n",person[i].name);
	}
}

int main() {
	test();
	return 0;
}

运行结果：

 

 

 

结构体深拷贝和浅拷贝

 

栈上

逐字节拷贝

下面代码中会申请两块内存空间person1和person2.当进入复制操作的时候，person1中的内容会被逐字节拷贝到person2中去。

struct Person{
	char name[64];
};

void test() {
	struct Person person1 = { "aaa" };
	struct Person person2 = { "bbb" };

	person2 = person1;

}

 

堆上

对于同一结构体的对象，结构体指针的size是一样的

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

struct Person{
	char *name;	
};

void test() {
    struct Person person1;
    person1.name = (char*)malloc(sizeof(char) * 64);
    memset(person1.name, 0, 64);
    strcpy(person1.name, "aaa");

    struct Person person2;
    person2.name = (char*)malloc(sizeof(char) * 128);
    memset(person2.name, 0, 128);
    strcpy(person2.name, "bbbbbb");

    printf("person1 size :%d\n", sizeof(person1));
    printf("person2 size :%d\n", sizeof(person2));

    //释放内存
    if (person1.name != NULL) {
        free(person1.name);
        person1.name = NULL;
    }
    if (person2.name != NULL) {
        free(person2.name);
        person2.name = NULL;
    }

}

int main() {
	test();
	return 0;
}

运行结果：

 

 

注意，默认的结构体赋值是浅拷贝动作，会出现问题

如果上面的代码添加一句：person2=person1; 就会出现问题

因为同一块内存你会释放两次，解释如下图

 

 

因此我们可以得知：

如果结构体内有指针，并且指针指向堆空间。那么如果发生赋值行为，就会产生问题。

1、同一块内存被释放两次

2、内存泄漏。

 

 

将上述代码改成深拷贝

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

struct Person{
	char *name;	
};

void test() {
	struct Person person1;
	person1.name = (char*)malloc(sizeof(char) * 64);
	memset(person1.name, 0, 64);
	strcpy(person1.name, "aaa");

        struct Person person2;
        person2.name = (char*)malloc(sizeof(char) * 128);
        memset(person2.name, 0, 128);
        strcpy(person2.name, "bbbbbb");

	printf("person1 size :%d\n", sizeof(person1));
	printf("person2 size :%d\n", sizeof(person2));

	//释放内存
	if (person1.name != NULL) {
		free(person1.name);
		person1.name = NULL;
	}

        //深拷贝
	person1.name=malloc(strlen(person2.name)+1);
	strcpy(person1.name, person2.name);
	
	if (person2.name != NULL) {
		free(person2.name);
		person2.name = NULL;
	}

}

int main() {
	test();
	return 0;
}

 

 

结构体指针

实现代码

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

struct Person{
	char* name;
	int age;
};

//分配内存
struct Person** allocateSpace(){
	struct Person **temp=malloc(sizeof(struct Person *)*3);
	
	//为每一个指针指向的地址分配内存
	for(int i=0; i<3; i++){
		temp[i]=malloc(sizeof(struct Person));
		//为每一个Person结构体中的name指针申请内存
		temp[i]->name=malloc(sizeof(char)*64);
		sprintf(temp[i]->name, "Name_%d", i+1);
		temp[i]->age=100+i;
	}
	return temp;
}

//打印
void print(struct Person **person){
	if(person==NULL) return;

	for(int i=0; i<3; ++i){
		printf("name:%s  age:%d\n", person[i]->name, person[i]->age);
	}
}

//释放内存
void freeSpace(struct Person **person){
	
	if(person==NULL) return;
	
	for(int i=0; i<3; i++){
		if(person[i]==NULL) continue;
		
		if(person[i]->name!=NULL){
			free(person[i]->name);
			person[i]->name=NULL;
		}		
		
		free(person[i]);
		person[i]=NULL;
	}

	free(person);
	person=NULL;
}

void test(){
	struct Person **person=NULL;
	person=allocateSpace();
	print(person);
	freeSpace(person);
}

int main(){
	test();
	return 0;
}

运行结果

 

 

王小闹儿
关注
专栏目录
【C++/嵌入式梳理】一、22.指针与数组 | 指针与函数
Hi
05-24 825
【C++/嵌入式笔试面试八股】一、22.指针与数组 | 指针与函数
指针数组、数组指针
jakezhang1990的专栏
04-01 526
在C语言和C++等语言中， 数组元素全为指针变量的数组称为指针数组。 指针数组中的元素都必须具有相同的存储类型、指向相同数据类型的指针变量。 指针数组比较适合用来指向若干个字符串，使字符串处理更加方便、灵活。 数组指针 是指向数组首元素的地址的指针，其本质为指针（这个指针存放的是数组首地址的地址，相当于2级指针，这个指针不可移动）； 指针数组是数组元素为指针的数组，其本质为数组。 数组指针 只是一个指针变量，是C 语言里专门用来指向二维数组的，它占有内存中一个指针的存储空间。 指针数组是多个指针变量，以数组
指针数组与数组指针
W0LVEs_的博客
08-20 115
一、指针与数组 指针是编程语言中的一个对象，利用地址，它的值直接指向存在电脑存储器中另一个地方的值。由于通过地址能找到所需的变量单元，可以说，地址指向该变量单元。总的来说指针就是变量，用来存放地址的变量。（存放在指针中的值都被当成地址处理） int main() { int a = 10; //在内存中开辟一块空间 int *p = &a; //这里我们对变量a，取出它的地址，可以使用&操作符 //将a的地址存放在p变量中
数组指针——指向数组首元素和指向数组的区别
hambaga的博客
11-20 5889
指向数组 指向数组首元素 数组指针
指向数组的指针与指向数组首元素的指针
geekwang的专栏
05-12 1万+
我的主力博客：半亩方塘 以下原创内容，转载请注明地址，欢迎对以下内容提供不同参考意见： 指向数组的指针与指向数组首元素的指针究竟有什么区别呢？有人说，这二者不是一回事么？它们就是同一个东西啊！然而，事实并非如此，下面我细细道来。 首先，我们定义一个一维数组来具体分析一下，这个数组含有10个整数： int ia[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8
数组首地址和指针本质的差别
wq3028的博客
05-22 1631
数组首地址为一个常量，而指针是一个变量 数组首地址不可以作为左值(常量不可以作为左值)，而指针可以 指向数组首地址的指针在功能上等同于数组首地址，使用sizeof时候数组首地址等同于数组本身 ...
结构体嵌套、结构体数组、结构体指针
靡不有初，鲜克有终。
02-29 1889
结构体嵌套： 将一个已经声明的结构体在另一个结构体内作为成员变量进行定义，并在外层结构体初始化的同时最自己进行行初始化，使用花括号包裹自身成员变量。 打印时注意为：结构体名称.结构体成员结构体.结构体成员结构体的成员 #include <stdio.h> struct Date { int year; int month; int day; }; struct Boo...
C语言中对于基本指针，数组地址与首元素地址区别的理解
yinyoushiren_wb的博客
01-15 1592
C语言指针基础的入门感悟（一），拒接枯燥，拒绝不好理解。
结构体数组详细介绍.zip
最新发布
03-04
在编程领域，结构体数组是一种非常重要的数据结构，它结合了结构体和数组的概念，使得我们可以在一个数组中存储多个具有相同结构的元素。结构体是C/C++等编程语言中定义复杂数据类型的一种方式，它允许我们将多个...
C语言指针的28个应用案例代码.rar
03-31
11. **指针与指针数组**：一个数组可以包含多个指针，每个指针指向不同的数据。这种机制在创建多个相同类型对象的数组时很有用。 12. **指针与函数指针**：函数指针可以存储函数的地址，使得函数可以作为其他函数的...
通过结构体某个成员的地址计算结构体首地址 (转)
weixin_30510153的博客
04-01 163
最近在CU论坛上有很多人在问这样一个问题：给出一个结构体成员的地址计算该结构体的起始地址。其实这个题我之前也没有接触过，据说内核代码中有这样用的，但还没有看到。不过觉得这个题的解决方法还是有一定技巧的，就总结一下。下面是实现的代码。 1 #include <stdio.h> 2 #include <stdlib.h> 3 #define STRUCT_...
数组首地址给赋给 指针的问题
一颗偏执的心
05-15 8100
#include #include void sort(int* in, int len, int** out); void sort(int* in, int len, int** out) {   *out = in; //把数组首地址给out指针,在此时，是正确的！                 //也就是in， out 指向的是同一内存区域！
问题剖析：指向数组的指针与指向数组首元素的指针。
weixin_49503250的博客
02-11 561
这两行代码看似很像，但是指向的完全不是一个东西。还有要分清数组和数组首元素的概念，要牢记大袋子，小袋子，和糖果的比喻。不要再混淆了！！！
数组指针和数组首地址
hopeneversleep的博客
07-31 1917
下面代码会输出什么（） 1 2 3 4 5 6 int main(int argc, char **argv) {     int a[4] = {1, 2, 3, 4};     int *ptr = (int *)(&a + 1);     printf("%d", *(ptr - 1)); }
数组首地址和指针
yijing21的专栏
08-23 1932
main(){int a[5]={1,2,3,4,5};int *ptr=(int *)(&a+1);//这个是数组的偏移printf("%d,%d",*(a+1),*(ptr-1));}输出：2,5*(a+1）就是a[1]，*(ptr-1)就是a[4],执行结果是2，5&a+1不是首地址+1，系统会认为加一个a数组的偏移，是偏移了一个数组的大小（本例是5个int）int *ptr=(int *)
c语言指针指向数组首地址,C语言指向数组元素的指针
weixin_29817791的博客
05-19 8386
指向数组元素的指针和运算法则所谓指向数组元素的指针，其本质还是变量的指针。因为数组中的每个元素，其实都可以直接看成是一个变量，所以指向数组元素的指针，也就是变量的指针。指向数组元素的指针不难，但很常用。我们用程序来解释会比较直观一些。unsigned char number[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};unsigned char *p;如果我们写 p ...
解析：数组名a、数组名取地址&a、数组首地址&a[0]、数组指针*p
热门推荐
loongkingwhat的博客
12-27 5万+
数组和指针向来就是傻傻分不清，当他们一起出现的时候就更加懵逼。使用实例详细解析：数组名a、数组名取地址&a、数组首地址&a[0]、数组指针*p
C语言总结（三）
jkhero的博客
05-10 379
C语言总结(三)二级指针二级指针也是指针变量，指针都是存储地址的变量，而二级指针是存储所指向的一级指针变量的地址，通过二级指针的解引用可以得到一级指针变量。 二级指针作为函数参数 作用：在函数外部顶一个指针p，在函数内给指针赋值，函数结束后对指针p神效，那么我们就需要二级指针。
指针、数组名与数组首元素地址的关系
pl0020的博客
07-15 8311
数组名等价于等同于指向数组首元素的指针！！！/* *copyright(c) 2018,HH *All rights reserved. *作 者：HH *完成日期：2018年7月15日 *版本号：v1.0 * *问题描:指针、数组名与数组首个元素地址的关系！ *输入描述：； *程序输出：；。 */ #include&lt;stdio.h&gt; int main() { int a[5]...
学习C语言指针与结构体的基础知识 - PPT课件介绍
同时，课件还介绍了结构体的指针、结构体嵌套、结构体数组等内容，帮助学生更好地理解结构体的用法和操作。 通过学习《C语言的指针和结构体ppt课件.ppt》，我们可以更深入地了解C语言中指针和结构体的概念与用法。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值