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

最新推荐文章于 2023-02-11 11:58:07 发布
最新推荐文章于 2023-02-11 11:58:07 发布
阅读量256 收藏 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;
}

运行结果

 

 

王小闹儿
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
指针数组、数组指针
jakezhang1990的专栏
04-01 496
在C语言和C++等语言中， 数组元素全为指针变量的数组称为指针数组。 指针数组中的元素都必须具有相同的存储类型、指向相同数据类型的指针变量。 指针数组比较适合用来指向若干个字符串，使字符串处理更加方便、灵活。 数组指针 是指向数组首元素的地址的指针，其本质为指针（这个指针存放的是数组首地址的地址，相当于2级指针，这个指针不可移动）； 指针数组是数组元素为指针的数组，其本质为数组。 数组指针 只是一个指针变量，是C 语言里专门用来指向二维数组的，它占有内存中一个指针的存储空间。 指针数组是多个指针变量，以数组
指针数组与数组指针
W0LVEs_的博客
08-20 87
一、指针与数组 指针是编程语言中的一个对象，利用地址，它的值直接指向存在电脑存储器中另一个地方的值。由于通过地址能找到所需的变量单元，可以说，地址指向该变量单元。总的来说指针就是变量，用来存放地址的变量。（存放在指针中的值都被当成地址处理） int main() { int a = 10; //在内存中开辟一块空间 int *p = &a; //这里我们对变量a，取出它的地址，可以使用&操作符 //将a的地址存放在p变量中
数组指针——指向数组首元素和指向数组的区别
hambaga的博客
11-20 5760
指向数组 指向数组首元素 数组指针
指向数组的指针与指向数组首元素的指针
geekwang的专栏
05-12 1万+
我的主力博客：半亩方塘 以下原创内容，转载请注明地址，欢迎对以下内容提供不同参考意见： 指向数组的指针与指向数组首元素的指针究竟有什么区别呢？有人说，这二者不是一回事么？它们就是同一个东西啊！然而，事实并非如此，下面我细细道来。 首先，我们定义一个一维数组来具体分析一下，这个数组含有10个整数： int ia[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8
数组首地址和指针本质的差别
wq3028的博客
05-22 1584
数组首地址为一个常量，而指针是一个变量 数组首地址不可以作为左值(常量不可以作为左值)，而指针可以 指向数组首地址的指针在功能上等同于数组首地址，使用sizeof时候数组首地址等同于数组本身 ...
《C语言结构体》PPT课件.ppt
12-18
本资源摘要信息涵盖了C语言结构体的基本概念、定义、嵌套定义、结构变量的定义和初始化、结构成员的引用、结构数组的定义和使用、结构指针的使用等知识点，为您提供了一个全面的C语言结构体知识框架。
2022年全国计算机等级考试二级C语言程序设计考试大纲.docx
07-05
* 一维数组和二维数组的定义、初始化和数组元素的引用 * 字符串与字符数组 这些知识点是 C 语言程序设计的数组，掌握这些知识点是编写高效的 C 程序的关键。 七、函数 * 库函数的正确调用 * 函数的定义方法 * ...
C语言进阶 作者 Wrestle.Wu
06-20
 堆和栈、全局变量和局部变量、生存期和作用域、内部函数和外部函数、指针变量、指针数组和数组指针、指针函数和函数指针、传址和传值、递归和嵌套、结构体和共用体、枚举、位域等较难理解的核心概念的阐述和对比...
新概念C语言.李一波(带详细书签).pdf
02-10
7.2 函数之间对一维数组和数组元素的引用 47 7.2.1 数组元素做实参 47 7.2.2 数组名做实参 49 7.3 一维数组应用举例 50 7.4 字符数组 53 7.4.1 字符数组的定义 53 7.4.2 字符数组的初始化 54 7.4.3 字符数组...
二级c未来教育题库破解及资源
09-25
１.一维数组和二维数组的定义、初始化和数组元素的引用。 ２.字符串与字符数组。 七、函数 １.库函数的正确调用。 ２.函数的定义方法。 ３.函数的类型和返回值。 ４.形式参数与实际参数，参数值的传递。 ５....
通过结构体某个成员的地址计算结构体首地址 (转)
weixin_30510153的博客
04-01 148
最近在CU论坛上有很多人在问这样一个问题：给出一个结构体成员的地址计算该结构体的起始地址。其实这个题我之前也没有接触过，据说内核代码中有这样用的，但还没有看到。不过觉得这个题的解决方法还是有一定技巧的，就总结一下。下面是实现的代码。 1 #include <stdio.h> 2 #include <stdlib.h> 3 #define STRUCT_...
数组首地址给赋给 指针的问题
一颗偏执的心
05-15 7965
#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 485
这两行代码看似很像，但是指向的完全不是一个东西。还有要分清数组和数组首元素的概念，要牢记大袋子，小袋子，和糖果的比喻。不要再混淆了！！！
数组指针和数组首地址
hopeneversleep的博客
07-31 1881
下面代码会输出什么（） 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 1904
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 8068
指向数组元素的指针和运算法则所谓指向数组元素的指针，其本质还是变量的指针。因为数组中的每个元素，其实都可以直接看成是一个变量，所以指向数组元素的指针，也就是变量的指针。指向数组元素的指针不难，但很常用。我们用程序来解释会比较直观一些。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 4万+
数组和指针向来就是傻傻分不清，当他们一起出现的时候就更加懵逼。使用实例详细解析：数组名a、数组名取地址&a、数组首地址&a[0]、数组指针*p
C语言总结（三）
jkhero的博客
05-10 346
C语言总结(三)二级指针二级指针也是指针变量，指针都是存储地址的变量，而二级指针是存储所指向的一级指针变量的地址，通过二级指针的解引用可以得到一级指针变量。 二级指针作为函数参数 作用：在函数外部顶一个指针p，在函数内给指针赋值，函数结束后对指针p神效，那么我们就需要二级指针。
指针、数组名与数组首元素地址的关系
pl0020的博客
07-15 8172
数组名等价于等同于指向数组首元素的指针！！！/* *copyright(c) 2018,HH *All rights reserved. *作 者：HH *完成日期：2018年7月15日 *版本号：v1.0 * *问题描:指针、数组名与数组首个元素地址的关系！ *输入描述：； *程序输出：；。 */ #include&lt;stdio.h&gt; int main() { int a[5]...
如何使用结构体数组指针遍历结构体数组的所有元素？
最新发布
10-09
使用结构体数组指针遍历结构体数组的所有元素可以按照以下步骤进行： 1. 声明一个结构体类型和一个结构体数组指针变量 2. 动态分配结构体数组所需的内存空间 3. 初始化结构体数组中的元素 4. 使用结构体数组指针遍历结构体数组的所有元素 以下是示例代码： ```c #include <stdio.h> #include <stdlib.h> struct Student { char name[20]; int age; float score; }; int main() { struct Student *pStu; // 声明结构体数组指针 int n = 3; // 结构体数组的元素个数 // 动态分配内存空间 pStu = (struct Student *)malloc(n * sizeof(struct Student)); // 初始化结构体数组 for (int i = 0; i < n; i++) { sprintf((pStu + i)->name, "Student%d", i+1); (pStu + i)->age = 18 + i; (pStu + i)->score = 60.0 + i; } // 遍历结构体数组的所有元素 for (int i = 0; i < n; i++) { printf("Name: %s, Age: %d, Score: %.1f\n", (pStu + i)->name, (pStu + i)->age, (pStu + i)->score); } // 释放内存空间 free(pStu); return 0; } ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值