① 關於c語言的共用體
在進行某些演算法的C語言編程的時候，需要使幾種不同類型的變數存放到同一段內存單元中。也就是使用覆蓋技術，幾個變數互相覆蓋。這種幾個不同的變數共同佔用一段內存的結構，在C語言中，被稱作「共用體」類型結構，簡稱共用體。註：在某些書籍中可能稱之為「聯合體」，但是「共用體」更能反映該類型在內存的特點。
共用體類型數據的特點
1.同一個內存段可以用來存放幾種不同類型的成員，但是在每一瞬間只能存放其中的一種，而不是同時存放幾種。換句話說，每一瞬間只有一個成員起作用，其他的成員不起作用，即不是同時都在存在和起作用。
2.共用體變數中起作用的成員是最後一次存放的成員，在存入一個新成員後，原有成員就失去作用。
3.共用體變數的地址和它的各成員的地址都是同一地址。
4.不能對共用體變數名賦值，也不能企圖引用變數名來得到一個值。
5.共用體類型可以出現在結構體類型的定義中，也可以定義共用體數組。反之，結構體也可以出現在共用體類型的定義中，數組也可以作為共用體的成員。
② c語言中的共用體是什麼
所謂共用體類型是指將不同的數據項組織成一個整體，它們在內存中佔用同一段存儲單元。其定義形式為：
union 共用體名
{成員表列}；
union data
{
int a ;
float b;
doublec;
chard;
}obj;
該形式定義了一個共用體數據類型union data ，定義了共用體數據類型變數obj。共用體數據類型與結構體在形式上非常相似，但其表示的含義及存儲是完全不同的。先讓我們看一個小例子。
union data /*共用體*/
{
int a;
float b;
double c;
char d;
}mm;
struct stud /*結構體* /
{
int a;
float b;
double c;
char d;
};
main( )
{
struct stud student;
printf("%d,%d",sizeof(struct stud),sizeof(union data));
}
運行程序輸出：
15，8
程序的輸出說明結構體類型所佔的內存空間為其各成員所佔存儲空間之和。而形同結構體的共用體類型實際佔用存儲空間為其最長的成員所佔的存儲空間。
對共用體的成員的引用與結構體成員的引用相同。但由於共用體各成員共用同一段內存空間，使用時，根據需要使用其中的某一個成員。從圖中特別說明了共用體的特點，方便程序設計人員在同一內存區對不同數據類型的交替使用，增加靈活性，節省內存。
可以引用共用體變數的成員，其用法與結構體完全相同。若定義共用體類型為：
union data /*共用體*/
{
int a;
float b;
double c;
char d;
}mm;
其成員引用為：mm.a,mm.b,mm.c,mm.d 但是要注意的是，不能同時引用四個成員，在某一時刻，只能使用其中之一的成員。
main( )
{
union data
{
int a;
float b;
double c;
char d;
}mm;
mm.a=6;
printf("%d\n",mm.a);
mm.c=67.2;
printf("%5.1lf\n", mm.c);
mm.d='W';
mm.b=34.2;
printf("%5.1f,%c\n",mm.b,mm.d);
}
運行程序輸出為：
6
6 7.2
3 4.2,=
程序最後一行的輸出是我們無法預料的。其原因是連續做mm.d='W'；mm.b=34.2；兩個連續的賦值語句最終使共用體變數的成員mm.b所佔四位元組被寫入34.2，而寫入的字元被覆蓋了，輸出的字元變成了符號「 =」。事實上，字元的輸出是無法得知的，由寫入內存的數據決定。
例子雖然很簡單，但卻說明了共用體變數的正確用法。
③ c語言結構體與共用體
#include<stdio.h>
#include<stdlib.h>
struct student{
int number;
char name[15];
double score[3];
};
void Display_All(struct student * p,int count);
void Display_Average(struct student * p_student,int count);
int cmp(const void *a,const void *b);
void main()
{
int i=0;
int count_student;
printf("how many student:\n");
scanf("%d",&count_student);
struct student * p_student=malloc(sizeof(struct student)
*count_student);
printf("please enter student's data:\n");
//從鍵盤輸入學生們的數據
for(i=0;i<count_student;i++)
{
printf("number:");
scanf("%d",&(p_student+i)->number);
printf("name:");
scanf("%s",(p_student+i)->name);
printf("first score:");
scanf("%lf",&(p_student+i)->score[0]);
printf("second score:");
scanf("%lf",&(p_student+i)->score[1]);
printf("third score:");
scanf("%lf",&(p_student+i)->score[2]);
}
//輸出成績報表
Display_All(p_student,count_student);
Display_Average(p_student,count_student);
}
int cmp(const void *a,const void *b)
{
return (((struct student*) a)->score[0]+((struct student*) a)-
>score[1]+((struct student*) a)->score[2])/3>(((struct student*) b)->score
[0]+((struct student*)b)->score[1]+((struct student*) b)->score[2])/3?-1:1;
}
//並輸出成績報表（包括每人的學號，姓名，三門成績及平均分數）
void Display_All(struct student* p_student,int count)
{
int i=0;
printf("number name first_score second_score third_score
average_score\n");
for(i=0;i<count;i++)
{
printf("%-8d%-10s%-13lf%-14lf%-14lf%-14lf\n",(p_student
+i)->number,(p_student+i)->name,(p_student+i)->score[0],(p_student+i)-
>score[1],(p_student+i)->score[2],((p_student+i)->score[0]+(p_student+i)-
>score[1]+(p_student+i)->score[2])/3);
}
}
//輸出平均分在前五名的學生姓名及平均成績
void Display_Average(struct student * p_student ,int count)
{
int i;
qsort(p_student,count,sizeof(struct student),cmp);
printf("name average_score\n");
for(i=0;i<2;i++)
{
printf("%-8s%-lf\n",(p_student+i)->name,((p_student+i)-
>score[0]+(p_student+i)->score[1]+(p_student+i)->score[2])/3);
}
}
④ 結構體和共用體在c語言中是怎麼用的
結構體和共用體其實都是用來描述一組由不同類型變數的集合，也就是說結構體和共用體中都可以同時存在int型、char型、float型等等！！
但是不同的是，結構體內所定義的每一個變數都有其自己獨立的存儲空間，互不幹涉，比如一個結構體中有一個int型、同時有一個char型，那麼它們是獨立的，總共佔用三個位元組空間。
而共用體內定義的每一個變數都共同享有同一個存儲空間，存儲空間的大小是佔用空間最大的那個一變數的大小。比如，我還是在裡面有一個int型和一個char型，那這個共用體就佔int型的2個位元組，加入我用共用體存入一個char型數據，我可以用int型來讀取，讀的是二進制數據。
呵呵呵呵，c語言是很久以前學的了，不知道這點記憶對不對，但是希望能幫得到你。
⑤ C語言 結構體共用體
你使用的 是共同體 再使用 的結構題 .. 開辟的內存 還 是一起使用的 .
例：
1.使用 公用體 定義 的
char a;
int b;
float c;
三個變數 . 那麼 a,b,c 佔用 同一個內存單元 .
且褲飢這個共用 存儲單元存。進去的 類型 可以是 char 或 int 或 float 。
2.使用胡拆返 結構體 定義
char a;
int b;
float c;
三個變數 . 那麼 a,b,c 佔用 同三個不同類型內存單元.
---
union 公用體
struct 結構題
解決 ：
把最後 的 a.k=0 修改成 a.k=4 。就可以把 a.u.z=6 這個數值給覆御滾蓋掉 ，最後的 結果也是 4了
⑥ C語言 結構體 共用體
scanf("%d%s%c%c",&per[i].son,per[i].name,&per[i].sex,&per[i].job);
//name是[]不用&，job是char，需要&
⑦ C語言結構體共用體問題
最後那清笑枯里答洞的
if(v=="student")
printf("%d",q->x->升晌banji);
if(v=="teacher")
printf("%s",q->x->wei);
改成q->x.banji，q->x.wei
⑧ C語言-結構體和共用體題型
結構體(structure)是一個或多個相同數據類型或不同數據類型的變數集合在一個名稱下的用戶自定義數據類型
共用體是在同一存儲空間上存不同類型的數據，用於節省空間
而c語言磨寬中培游含的函數和高中數學的函數是不同的，數學中的函數是一個具配笑體的解析表達式；而c語言中的函數是實現某一功能的一段代碼
⑨ C語言 結構體共用體問題
typedef union //定義共用體
{
long i; //long 四個位元組
int k[5]; //int 四個位元組 4*5 = 20
char c; //char 一個位元組：
}DATE;
上面的結構體是聯合凱頌搭：聯合的結構體取中間最大的就可以了，因為他們是公用的，所以找到最大的空間，那麼小的也能裝在大的裡面，如果你取小的，那麼大的就不能裝在小的裡面了；
分析一下：上面最大的是：20
struct date //定義結構體
{
int cat; //int 四個位元組
DATE cow; //DATE 一個聯合體：20個位元組
double dog; //double 8個位元組
}too;
//上面的結構體不是聯合的，所以：就應該是4+20+8 = 32
因此答案就是：20+32 =52
我個人覺得如果你要對結構體了解的話，這個事遠遠不夠的
比如說：
struct date //定義結構體
{
int cat; //int 四個位元組
DATE cow; //DATE 一個聯合體：20個位元組
double dog; //double 8個櫻團位元組
char a;
}too;
如果考慮對齊的話：
我在上面的結構體里加了一個char a，那麼現在結構體多大呢 你說是53，54，56，這樣其實都是對的?為什麼呢？
因為這個要取決於你的機器是按什麼對齊的。
看下面的一段代碼：
#pragma pack(push)
#pragma pack(n)
struct date //定義結構體
{
int cat; //int 四個位元組
DATE cow; //DATE 一個聯合體：20個位元組
double dog; //double 8個位元組
char a;
}too;
#pragma pack(pop)
對於這個結構體：對齊方式就取決於#pragma pack(n)中n的取值了，如果n=4,那麼上面的結構體就是：56，如果n = 1,那麼就是53，n=2那麼就是54，切忌這里的N只能為：1，2 ， 4， 8
不過現在的計算機的內存都很大了，不需要節省內存，一般都是四個位元組對盯拿齊的。默認的是四個位元組，但是在嵌入式領域里，一般都是按一個位元組對齊的。
下面為了加深你的了解：給你點資料。呵呵
DATE maxx;
#pragma pack(pop)
int main()
{
printf("%d",sizeof(struct date)+sizeof(maxx)); /*相當於struct date這個結構體所佔空間大小加上DATE max這個結構體所佔空間的大小。*/
return 0;
}
這是初學者問得最多的一個問題，所以這里有必要多費點筆墨。讓我們先看一個*
結構*體：
struct S1
{
char c;
int i;
};
問*sizeof*(s1)*等*於多少？聰明的你開始思考了，char佔1個位元組，int佔4個字
節，那麼加起
來就應該是5。是這樣嗎？你在你機器上試過了嗎？也許你是對的，但很可能你是
錯的！V
C6中按默認設置得到的結果為8。
Why？為什麼受傷的總是我？
請*不*要沮喪，我們來好好琢磨一下*sizeof*的定義——*sizeof*的結果*等*於對象
或者類型所佔
的內存位元組數，好吧，那就讓我們來看看S1的內存分配情況：
S1 s1 = { a , 0xFFFFFFFF };
定義上面的變數後，加上斷點，運行程序，觀察s1所在的內存，你發現了什麼？
以我的VC6.0為例，s1的地址為0x0012FF78，其數據內容如下：
0012FF78: 61 CC CC CC FF FF FF FF
發現了什麼？怎麼中間夾雜了3個位元組的CC？看看MSDN上的說明：
When applied to a structure type or variable, *sizeof* returns the
actual size,
which may include padding bytes inserted for alignment.
原來如此，這就是傳說中的位元組對齊啊！一個重要的話題出現了。
為什麼需要位元組對齊？計算機組成原理教導我們這樣有助於加快計算機的取數速
度，否則
就得多花指令周期了。為此，編譯器默認會對*結構*體進行處理（*實際*上其它地
方的數據變
量也是如此），讓寬度為2的基本數據類型（short*等*）都位於能被2整除的地址
上，讓寬度
為4的基本數據類型（int*等*）都位於能被4整除的地址上，以此類推。這樣，兩
個數中間就
可能需要加入填充位元組，所以整個*結構*體的*sizeof*值就增長了。
讓我們交換一下S1中char與int的位置：
struct S2
{
int i;
char c;
};
看看*sizeof*(S2)的結果為多少，怎麼還是8？再看看內存，原來成員c後面仍然有
3個填充字
節，這又是為什麼啊？別著急，下面總結規律。
位元組對齊的細節*和*編譯器實現相關，但一般而言，滿足三個准則：
1) *結構*體變數的首地址能夠被其最寬基本類型成員的大小所整除；
2) *結構*體每個成員相對於*結構*體首地址的偏移量（offset）都是成員大小的
整數倍，如有
需要編譯器會在成員之間加上填充位元組（internal adding）；
3) *結構*體的總大小為*結構*體最寬基本類型成員大小的整數倍，如有需要編譯
器會在最末一
個成員之後加上填充位元組（trailing padding）。
對於上面的准則，有幾點需要說明：
1) 前面*不*是說*結構*體成員的地址是其大小的整數倍，怎麼又說到偏移量了
呢？因為有了第
1點存在，所以我們就可以只考慮成員的偏移量，這樣思考起來簡單。想想為什麼。
*結構*體某個成員相對於*結構*體首地址的偏移量可以通過宏offsetof()來獲得，
這個宏也在
stddef.h中定義，如下：
#define offsetof(s,m) (size_t)&(((s *)0)->m)
例如，想要獲得S2中c的偏移量，方法為
size_t pos = offsetof(S2, c);// pos*等*於4
2) 基本類型是指前面提到的像char、short、int、float、double這樣的內置數據
類型，
這里所說的「數據寬度」就是指其*sizeof*的大小。由於*結構*體的成員可以是復合
類型，比
如另外一個*結構*體，所以在尋找最寬基本類型成員時，應當包括復合類型成員的
子成員，
而*不*是把復合成員看成是一個整體。但在確定復合類型成員的偏移位置時則是將
復合類型
作為整體看待。
這里敘述起來有點拗口，思考起來也有點撓頭，還是讓我們看看例子吧（具體數值
仍以VC
6為例，以後*不*再說明）：
struct S3
{
char c1;
S1 s;
char c2
};
S1的最寬簡單成員的類型為int，S3在考慮最寬簡單類型成員時是將S1「打散」看
的，所以
S3的最寬簡單類型為int，這樣，通過S3定義的變數，其存儲空間首地址需要被4整
除，整
個*sizeof*(S3)的值也應該被4整除。
c1的偏移量為0，s的偏移量呢？這時s是一個整體，它作為*結構*體變數也滿足前
面三個准則
，所以其大小為8，偏移量為4，c1與s之間便需要3個填充位元組，而c2與s之間就*不
*需要了，
所以c2的偏移量為12，算上c2的大小為13，13是*不*能被4整除的，這樣末尾還得
補上3個填
充位元組。最後得到*sizeof*(S3)的值為16。
通過上面的敘述，我們可以得到一個公式：
*結構*體的大小*等*於最後一個成員的偏移量加上其大小再加上末尾的填充位元組數
目，即：
*sizeof*( struct ) = offsetof( last item ) + *sizeof*( last item ) +
*sizeof*( trail
ing padding )
到這里，朋友們應該對*結構*體的*sizeof*有了一個全新的認識，但*不*要高興得
太早，有一個
影響*sizeof*的重要參量還未被提及，那便是編譯器的pack指令。它是用來調整*
結構*體對齊
方式的，*不*同編譯器名稱*和*用法略有*不*同，VC6中通過#pragma pack實現，
也可以直接修改
/Zp編譯開關。#pragma pack的基本用法為：#pragma pack( n )，n為位元組對齊
數，其取值
為1、2、4、8、16，默認是8，如果這個值比*結構*體成員的*sizeof*值小，那麼
該成員的偏移
量應該以此值為准，即是說，*結構*體成員的偏移量應該取二者的最小值，公式如
下：
offsetof( item ) = min( n, *sizeof*( item ) )
再看示例：
#pragma pack(push) // 將當前pack設置壓棧保存
#pragma pack(2)// 必須在*結構*體定義之前使用
struct S1
{
char c;
int i;
};
struct S3
{
char c1;
S1 s;
char c2
};
#pragma pack(pop) // 恢復先前的pack設置
計算*sizeof*(S1)時，min(2, *sizeof*(i))的值為2，所以i的偏移量為2，加上
*sizeof*(i)*等*於
6，能夠被2整除，所以整個S1的大小為6。
同樣，對於*sizeof*(S3)，s的偏移量為2，c2的偏移量為8，加上*sizeof*(c2)*等
*於9，*不*能被
2整除，添加一個填充位元組，所以*sizeof*(S3)*等*於10。
現在，朋友們可以輕松的出一口氣了，
還有一點要注意，「空*結構*體」（*不*含數據成員）的大小*不*為0，而是1。試想
一個「*不*占
空間」的變數如何被取地址、兩個*不*同的「空*結構*體」變數又如何得以區分呢？
於是，「
空*結構*體」變數也得被存儲，這樣編譯器也就只能為其分配一個位元組的空間用於
佔位了。
如下：
struct S5 { };
*sizeof*( S5 ); // 結果為1
8. 含位域*結構*體的*sizeof*
前面已經說過，位域成員*不*能單獨被取*sizeof*值，我們這里要討論的是含有位
域的*結構*體
的*sizeof*，只是考慮到其特殊性而將其專門列了出來。
C99規定int、unsigned int*和*bool可以作為位域類型，但編譯器幾乎都對此作了
擴展，允
許其它類型類型的存在。
使用位域的主要目的是壓縮存儲，其大致規則為：
1) 如果相鄰位域欄位的類型相同，且其位寬之*和*小於類型的*sizeof*大小，則
後面的欄位將
緊鄰前一個欄位存儲，直到*不*能容納為止；
2) 如果相鄰位域欄位的類型相同，但其位寬之*和*大於類型的*sizeof*大小，則
後面的欄位將
從新的存儲單元開始，其偏移量為其類型大小的整數倍；
3) 如果相鄰的位域欄位的類型*不*同，則各編譯器的具體實現有差異，VC6採取*
不*壓縮方式
，Dev-C++採取壓縮方式；
4) 如果位域欄位之間穿插著非位域欄位，則*不*進行壓縮；
5) 整個*結構*體的總大小為最寬基本類型成員大小的整數倍。
還是讓我們來看看例子。
示例1：
struct BF1
{
char f1 : 3;
char f2 : 4;
char f3 : 5;
};
其內存布局為：
|_f1__|__f2__|_|____f3___|____|
|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|
0 3 7 8 1316
位域類型為char，第1個位元組僅能容納下f1*和*f2，所以f2被壓縮到第1個位元組中，
而f3隻能
從下一個位元組開始。因此*sizeof*(BF1)的結果為2。
示例2：
struct BF2
{
char f1 : 3;
short f2 : 4;
char f3 : 5;
};
由於相鄰位域類型*不*同，在VC6中其*sizeof*為6，在Dev-C++中為2。
示例3：
struct BF3
{
char f1 : 3;
char f2;
char f3 : 5;
};
非位域欄位穿插在其中，*不*會產生壓縮，在VC6*和*Dev-C++中得到的大小均為3。
9. 聯合體的*sizeof*
*結構*體在內存組織上是順序式的，聯合體則是重疊式，各成員共享一段內存，所
以整個聯
合體的*sizeof*也就是每個成員*sizeof*的最大值。*結構*體的成員也可以是復合
類型，這里，
復合類型成員是被作為整體考慮的。
所以，下面例子中，U的*sizeof*值*等*於*sizeof*(s)。
union U
{
int i;
char c;
S1 s;
};
1）提高存取效率
一般處理器是32位的，一次可以從內存中讀取32位數據，一般分配給變數地址是4的倍數，如果你定義的結構成員橫跨了32位邊界，CPU要讀取2次。這里就是浪費了時間。
2）為了在不同處理器下兼容。
早期MIPS處理器只能讀取4位元組對齊的後的結構，非4倍數地址訪問，會造成死機問題。
3）VC一般默認8位元組對齊是為了配合64位處理器，8也是4的倍數，因此也適合32位處理器。但就是浪費內存。
4）內存緊張的嵌入式環境，常會需要1位元組對齊 。。
⑩ c語言中的共用體
我測試了一下
int為32bit
，long為32位
，char為8位機測試。
分析得出這樣的結果：
這正如共用結構體中
假如他們的共用首地址為0x10000000
那麼
地址
變數
0x10000000：
a[0]
如果執行語句
s.a[0]=0x39
0x10000004：
a[1]
相差4個位元組
那麼會產生如下變化：
0x10000000：
b
a[0]=0x39
b[0]=0x39
c[0]=0x39(
字元c[0]="9")
0x10000000：
c[0]
如果再執行語句
s.a[1]=0x38
0x10000001：
c[1]
那麼會產生如下變化：
0x10000002：
c[2]
a[1]=0x38
0x10000003：
c[3]
相差1個位元組
也即是地址0x10000000到0x10000003中的數據為0x00000039
也即是地址0x10000004到0x10000007中的數據為0x00000038
雖然是共用體，但是a
b
c同用了一個地址
如果對a賦值了也同時對b和c賦值
只是數據類型不同而已。
如果從地址上來分析
c如果定義的是c[8],那麼c[5]地址即為0x10000004
它的值就因該為0x38，因為和a[1]的地址相同。
查看b的是後可以直接用%d來查看
因為在本機上也是32bit和int相同