c语言结构体里引用结构体

Posted 2023-05-15

#include<stdio.h>
int main()

int n, i;
struct score

double a;
double b;
double c;
b[100];
struct student


int id; //学号

char name[20]; //姓名

struct score; //三门课成绩，取值在0.0-100.0

double aver; //平均成绩，保留两位小数

a[100];

scanf("%d", &n);

for(i=0; i<n; i++)

scanf("%d", &a[i].id);
scanf("%s", a[i].name);
scanf("%lf", &a[i].score.b[i].a);//这里改怎么写啊
scanf("%lf", &a[i].score.b[i].b);
scanf("%lf", &a[i].score.b[i].c);




结构体里用结构体，求大神帮忙啊！

#include
struct person

char name[10];
int num;
;

void main()

struct person per[5];
void sort(struct person *, int );
int i;
printf("print letter:\n");
for(i=0;i<5;i++)

printf("name: ");
scanf("%s", &per[i].name);
printf("num: ");
scanf("%d", &per[i].num);

sort(per, 5);
for(i=0;i<5;i++)
printf("print: %s%d\n", per[i].name, per[i].num);
getch();


void sort(struct person *a, int n)

int i,j,t;
for(i=0;i<n;i++)
for(j=0;j<n;j++)
if(a[i].num>a[j].num)

t=a[i].num; /*你代码中i写成j，这是细节问题*/
a[i].num=a[j].num;
a[j].num=t;



你代码有点问题，我给你改了改。TC测试通过。
除了注视的地方，还有几点要注意：
你源代码传送的是per[0].num的地址，记：a[0]，但是a[1]的地址不等于
per[1].num的地址。
指针加1的意思你没理解好。
举个列子。
int a[10];
那么*(a+1)的意思是把a地址向后移动sizeof(int)个位。
所以你那个&a[1]指向的还是结构体中的数据。（恩，这里体现了低级语言的特性。每一个内存的每一位都要考虑到。要是你写个程序：200位的浮点数加法计算机，你更能体会到什么叫做考虑到每一位内存，调试的时候要一个内存一个内存的演算。代码我的baidu空间里有，可以自己去看）

不懂的问 参考技术A struct score

double a;
double b;
double c;
;
struct student


int id; //学号
char name[20]; //姓名
score b[100];//三门课成绩，取值在0.0-100.0
double aver; //平均成绩，保留两位小数
a[100];
int main()

int n, i;
scanf("%d", &n);
for(i=0; i<n; i++)

scanf("%d", &a[i].id);
scanf("%s", &a[i].name);
scanf("%lf",&a[i].b[i].a);//这里改怎么写啊
scanf("%lf",&a[i].b[i].b);
scanf("%lf",&a[i].b[i].c);

return 0;
本回答被提问者采纳

c结构体里的数组与指针

/*
訪问成员数组名事实上得到的是数组的相对地址。而訪问成员指针事实上是相对地址里的内容
*/

struct buf_str
{
	int  length;
	char buf[0];
};

struct foo
{
	buf_str* pbuf;
};

void test_funny()
{
	foo f = {0};

	printf("%x\n", f.pbuf);
	printf("%x\n", &f.pbuf->length);
	printf("%x\n", &f.pbuf->buf);
	printf("%x\n", f.pbuf->buf);      
	
	if (f.pbuf->buf) //没有申请内存，可是能够訪问相对地址，*数组名就是相对地址*
	{
		//printf(f.pbuf->buf); //crash，等价于printf("%s", f.pbuf->buf);指针的内容
	}
}

struct buf_str1
{
	int  length;
	char *buf;
};

struct foo1
{
	buf_str1* pbuf;
};

void test_funny1()
{
	foo1 f = {0};

	printf("%x\n", &f.pbuf->length);
	printf("%x\n", &f.pbuf->buf); //指针的相对地址。 和前面的比較。也和以下的比較
	printf("%x\n", f.pbuf->buf); //指针所指内容的地址，*訪问指针，就是訪问相对地址里面的内容*  crash
	if (f.pbuf->buf) //crash, 訪问内容
	{
		printf(f.pbuf->buf);
	}
}

/*关于长度为0的数组，柔性数组意义*/
/*第一个意义是，方便内存释放。假设我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，
并把整个结构体返回给用户。用户调用free能够释放结构体，可是用户并不知道这个结构体内的成员
也须要free。所以你不能指望用户来发现这个事。所以，假设我们把结构体的内存以及其成员要的内存
一次性分配好了，并返回给用户一个结构体指针。用户做一次free就能够把全部的内存也给释放掉。

（读到这里，你一定会认为C++的封闭中的析构函数会让这事easy和干净非常多）


第二个原因是。这样有利于訪问速度。

连续的内存故意于提高訪问速度，也故意于降低内存碎片。
（事实上。我个人认为也没多高了，反正你跑不了要用做偏移量的加法来寻址）

*/

void test_funny2()
{
	printf("buf_str size : %d\n", sizeof(buf_str));//只输出4,零长度的数组是存在于结构体内的。可是不占结构体的size

	int buf_len = 10;
	//////////////////////////////////////////////////////////////////////////
	//长度为0数组的使用方法
	buf_str* pBuf = (buf_str*)malloc(sizeof(buf_str) + sizeof(char)*(buf_len+1));//连续的内存
	pBuf->length = buf_len+1;
	memset(pBuf->buf, ‘a‘, sizeof(char) * buf_len);
	pBuf->buf[buf_len] = ‘\0‘;
	printf("%d  %s\n", pBuf->length, pBuf->buf);
	free(pBuf);//只释放一次内存
	pBuf = NULL;
    //////////////////////////////////////////////////////////////////////////

	//////////////////////////////////////////////////////////////////////////
	//正常的申请
	buf_str1* pBuf1 = (buf_str1*)malloc(sizeof(buf_str1));  
	(pBuf1->buf) = (char*)malloc(sizeof(char)*(buf_len+1)); //内存可能不连续。须要两次释放
	pBuf1->length = buf_len+1;
	memset(pBuf1->buf, ‘a‘, sizeof(char) * buf_len);
	pBuf1->buf[buf_len] = ‘\0‘;
	printf("%d  %s\n", pBuf1->length, pBuf1->buf);
	free(pBuf1->buf);
	free(pBuf1);
	pBuf = NULL;
}

原文来自于

http://coolshell.cn/articles/11377.html

仅仅只是提取了主要内容，并測验