结构体的存储
你最好重写你的function1，因为你function1(sp, WORK,len,fd);
这样调用函数时参数都是值传递，也就是相当于把sp中的参数值复制了一份给function1使用，函数执行完退出后，这些值的空间也就被释放了，所以sp中的值没有改变。你可以这样写：
typedefstruct//绑定变量
{
intoid_name[BUFFER_SIZE];//OID值
intoid_len;//OID长度
intvalue_type;//变量值的类型
intvalue_len;//变量值的长度
intoid_value;//变量值的值
}variable_list_t;
typedefstruct
{
intget_snmp[BUFFER_SIZE];
inttotal_length;
intversion;//版本号
intcommunity[BUFFER_SIZE];//团体关键字
intcommand;//PUD类型
intreqid[BUFFER_SIZE];//请求标识
interrstat;//错误状态
interrindex;//错误索引
intp_type_start;
interrorstatus_start;
interrorIndex_start;
intoid_value_start;
intvarbing_start;
variable_list_tval;
}SNMP_t;
voidmain(void){
SNMP_tsp;
function1(&sp,WORK,len,fd);
}
function1(SNMP_t*snmp,WorkTypework,intlen,intfd){
snmp->total_length=work.xxx;
...
}
不知道你能看懂这段代码吗？其实最核心的问题是你要想在函数退出后改变函数参数的值，就必须使用地址传递
⑵ 一个结构体变量在内存中是如何存储的
结构体的变量的地址存储在栈中，然后在堆中开辟控件存储真实的数据。
⑶ C语言中结构体在内存中的存储方式
结构体在内存中的存储方式，和常规的C语言变量、常量存储方式类似，唯的不同在于对齐。
只所以要进行数据对齐是因为编译器对结构的存储的特殊处理能提高CPU存储变量的速度，一般来说，32位的CPU内存以4字节对齐，64位的CPU的以8字节的对齐。一般可以使用#pragma pack()来指出对齐的字节数。比如下面的代码，在debug会显示结构体test的内存大小为28，如果生成release版则所占内存大小为32 。
#include<stdio.h>
#ifdef_DEBUG
#pragmapack(4)
structtest
{
charx[13];//13
intd;//4
doublef;//8
}ss;
#else
#pragmapack(8)
structtest
{
charx[13];//13
intd;//4
doublef;//8
}ss;
#endif
intmain(void){
printf("%d ",sizeof(ss));
return0;
}
⑷ 结构体的要点 数据在内存中的存储形式
1 只有结构体变量才分配地址，而结构体的定义是不分配空间的。
2 结构体中各成员的定义和之前的变量定义一样，但在定义时也不分配空间。
3 结构体变量的声明需要在主函数之上或者主函数中声明，如果在主函数之下则会报错。
4 C语言中的结构体不能直接进行强制转换，只有结构体指针才能进行强制转换。
结构体类型变量需要访问其成员时，用.运算符，如果是指向结构体变量的指针访问时，需要用->,或者先对指针解引用，取到指向的结构体类型的变量，再通过.访问，但是要注意优先级。
结构体作为函数参数时，一般通过传指针的方式来传参，为的是减少内存占用。
原码，反码，补码
1.符号位表示方法一样
a. 三种表示方法均有符号位与数值位
b. 符号位表示一样，0表示正，1表示负
2.数值位表示方法不一样
原码
直接将二进制按照正负数的形式翻译成二进制就OK啦
反码
原码符号位不变，其他位按位取反就OK啦
补码
反码加1就得到补码
整数的原码，反码，补码都相同
对于整型数据来说，数据在内存中是以补码的形式存放的
大小端问题
大端（存储）模式，是指数据的低位保存在内存的高地址中，而数据的高位，保存在内存的低地址中；
小端（存储）模式，是指数据的低位保存在内存的低地址中，而数据的高位,，保存在内存的高地址中。
浮点型在内存中的存储
任意一个二进制数都可以表示为浮点数,为下列形式：（-1)^S * M *2^E
a.（-1）^S为符号位 —> S为0时，表示正数，S为1，表示负数
b. M表示有效数字 —>大于等于1，小于2
c. 2^E表示指数位
单精度浮点数存储模型
对于32位的浮点数，最高的1位是符号位S，接着的8位是指数E，剩下的23位为有效数字M
双精度浮点数存储模型
对于64位的浮点数，最高的1位是符号位S，接着的11位是指数E，剩下的52位为有效数字M。
字符数组
字符串常量是一个字符数组，例如：
“i am a string”
在字符串内部，字符数组以空字符 '\0' 结尾，程序可以通过检查空字符找到字符数组的结尾。字符串常量占据的存储单元数也因此比双引号内的字符数大 1。
字符指针
char *p;
p = "now is the time";
将一个指向该字符数组的指针赋值给 p。（C语言没有提供将整个字符串作为一个整体进行操作的运算符）
char a[] = "now is the time"; //定义一个数组
char *p = "now is the time"; //定义一个指针
a是一个仅仅足以存放初始化字符串以及空字符 '\0' 的一维数组，可以修改数组中的单个字符。
p是一个指针，其初值指向一个字符串常量，之后可以修改它指向其它字符串，可以输出它的内容中的某个字符，但修改不了它指向的字符串的内容。
⑸ c++中的结构体如何存储
C/C++中结构体的存储方式
结构体在内存的存放，遵循两个原则：
1、基本类型对齐原则：
Char
1
Short
2
Int
4
Long
4
Float
4
Double
8
2、结构体类型对齐原则：
以最大成员类型的对齐方式为准，即当需要增长时，增长最大成员类型所占用的字节数。
例子：vc.net2003下运行结果
#include
<iostream>
using
namespace
std;
struct
A
{
char
c1;
char
c2;
};
/*与A比较发现，当只有char类型时，以1个字节的速度增长*/
struct
B
{
char
c1;
char
c2;
char
c3;
};
struct
C
{
char
c1;
char
c2;
short
s;
};
/*与C比较发现，当引入short类型后，以2个字节的速度增长*/
struct
D
{
char
c1;
short
s;
char
c3;
};
struct
E
{
char
c;
short
s;
int
i;
};
/*与E比较发现，当引入int类型后，以4个字节的速度增长*/
struct
F
{
char
c;
int
i;
short
s;
};
struct
G
{
int
i;
char
c1;
char
c2;
short
s;
};
/*与G比较发现，short类型是以2的倍数来对齐的*/
struct
H
{
int
i;
char
c1;
short
s;
char
c2;
};
int
main()
{
cout
<<
"size
of
A
:
"
<<
sizeof(A)
<<
endl;
/*2字节*/
cout
<<
"size
of
B
:
"
<<
sizeof(B)
<<
endl;
/*3字节*/
cout
<<
"size
of
C
:
"
<<
sizeof(C)
<<
endl;
/*4字节*/
cout
<<
"size
of
D
:
"
<<
sizeof(D)
<<
endl;
/*6字节*/
cout
<<
"size
of
E
:
"
<<
sizeof(E)
<<
endl;
/*8字节*/
cout
<<
"size
of
F
:
"
<<
sizeof(F)
<<
endl;
/*12字节*/
cout
<<
"size
of
G
:
"
<<
sizeof(G)
<<
endl;
/*8字节*/
cout
<<
"size
of
H
:
"
<<
sizeof(H)
<<
endl;
/*12字节*/
char
c;
cin
>>
c;
return
0;
}
⑹ 请问:c语言中结构体成员在电脑中是如何存储的
是在一块连续的内存区中为每个成员变量都分配内存的，结构体所占用内存的大小是所有成员变量的内存和，如果想节约内存建议使用共用体，共用体所占内存为最大成员变量的内存大小
⑺ c语言结构体的问题，存储空间大小
win32
4字节对齐
变量内存的起始地址的边界是跟它类型一致的
比如int类型，可以认为它存在4的倍数的地址，short存在2字节倍数开始的地址，char存在1字节开始的地址，即任意地址
因此，回过头来看
第一个结构
假设int
a;///4字节倍数地
short
b;//推理a的末尾是4字节倍数地址也是2字节倍数地址，所以b是挨着a存的
char
c;//任意其实地址，挨着b存放
看起来7个字节就放下了，但是需要兼顾4字节对齐的原则，在末尾补了一个字节
第二个结构也类似
结构体与普通类型并无大区别，存储区域也一样的
⑻ 结构体是什么存储结构
结构体，就是在内存中按顺序存储每个结构体成员。
⑼ C语言——结构体，线性表的链式存储
结构体的数据类型是为了将不同数据类型，但相互关联的一组数据，组合成一个有机整体使用，就相当于是java中的一个对象中定义了一些不同的属性
struct 结构体类型名{
数据类型 数据项1；
数据类型 数据项2；
.....
};
例如：
struct Data{
int year;
int month;
int day;
};
间接定义法：先定义结构体类型，再定义结构体变量
struct Data data;
直接定义法：在定义结构体类型的同时，定义结构体变量
struct Data{
int year;
int month;
int day;
}data;
结构体变量.成员 ，其中通过成员运算符‘.’逐个访问其成员。
结构体变量={初始表}；
结构体数组的每一个元素，都是结构体类型数据，均包含结构体类型的所有成员。
struct std_student students[3]={
{.....};
{};
{};
};
结构体变量在内存中的起始地址称为结构体变量的指针。
struct Data data={2019,3,4};
struct Data *p=&data;
printf("%d",p->year);
一般指针变量printer指向结构体变量var：
var.成员
pointer->成员
(*pointer).成员
线性链表是线性表的链式存储结构，是一种物理存储单元上的非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现，因此，哎存储线性表中的数据元素的时候，一方面要存储数据元素的值，另一方面要存储各数据元素之间的逻辑关系，因此，将每一个节点分为两部分：数据域和指针域。
单链表的基本操作：创建，检索，插入，删除，修改。
struct 结构体名{
数据成员表；
struct 结构体名 *指针变量名；
}；
struct student{
long num;
char name[20];
int score ;
struct student *next;
};
利用malloc函数向系统申请分配链表节点的存储空间，返回存储区的首地址。
p=（struct student*）malloc（sizeof（struct student））；
需要使用free（p）来释放
线性表的基本操作：
结构体：
struct student{
int data;
struct student *next;
};
struct student stu2[5],stu1;
初始化单链表：
int Initiate(struct student *s){
if((s=(struct student*)malloc(sizeof(struct student)))==NULL){
return 0;
}
s->next=NULL;
}
单链表的插入（后插）：
main（）{
struct student *s=&stu1;
struct student *p=&stu2;
int i;
Initiate(s);
for(i=0;i<5;i++){
Initiate(p);
(p+i)->data=i;
(p+i)->next=s->next;
s->next=(p+i);
}
for(i=0;i<5;i++){
printf("%d",p[i].data);
}
}
结果：
单链表删除：
如果要删除线性表h中的第i个节点，首先要找到第i个节点并让指针p指向其前驱的第i-1个节点，然后删除第i个节点并释放被删除节点。
(p+1)->next=(p+1)->next->next;
free((p+2));