結構體的存儲
你最好重寫你的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));