1. C語言程序判斷電腦的CPU大小端怎麼解決
給段代碼供參考
intis_little_endian()
{
union
{
charc;
inti;
}u;
u.i=1;
returnu.c==1;
}
2. C語言測試大小端的問題
大端模式，是指數據的高位元組保存在內存的低地址中，而數據的低位元組保存在內存的高地址中，這樣的存儲模式有點兒類似於把數據當作字元串順序處理：地址由小向大增加，而數據從高位往低位放；
小端模式，是指數據的高位元組保存在內存的高地址中，而數據的低位元組保存在內存的低地址中，這種存儲模式將地址的高低和數據位權有效地結合起來，高地址部分權值高，低地址部分權值低，和我們的邏輯方法一致。
測試程序：
#include<stdio.h>
intmain(void)
{
inta=0x12345678;
unsignedchar*p=(unsignedchar*)&a;
if(0x78==*p)
{
printf("littleend ");
}
else
{
printf("bigend ");
}
return0;
}
3. C語言題目 這題和大小端有關嗎
會的，你可以調試的時候打開內存監視看一下這個地址，會發現是小端對齊的，存儲為3412cdab。取得首地址的內容為34.而大端對其的話則為abcd1234，所以急首地址的內容為ab。
4. C語言判斷處理器大小端對齊原理
大端模式，是指數據的高位元組保存在內存的低地址中，而數據的低位元組保存在內存的高地址中
小端模式，是指數據的高位元組保存在內存的高地址中，而數據的低位元組保存在內存的低地址中
上面c是一個共用體，給共用體中的a賦值為1.然後讀取b是否為1，當b為1是說明是小端模式，b為0則說明是大端模式。
注意共用體是一個int和一個char，所以才能判斷。
5. 大端模式和小端模式
具體如下：
1、大端模式：
大端模式，是指數據的高位，保存在內存的低地址中，而數據的低位，保存在內存的高地址中，這樣的存儲模式類似於把數據當作字元串順序處理。
地址由小向大增加，而數據從高位往低位放；小端模式，是指數據的高位保存在內存的高地址中，而數據的低位保存在內存的低地址中，這種存儲模式將地址的高低和數據位權有效地結合起來，高地址部分權值高，低地址部分權值低，和我們的邏輯方法一致。
在大端模式下，前16位應該這樣讀: e6 84 6c 4e ( 假設int佔4個位元組)。
記憶方法: 地址的增長順序與值的增長順序相反。
2、小端模式例子：
0000430: e684 6c4e 0100 1800 53ef 0100 0100 0000。
0000440: b484 6c4e 004e ed00 0000 0000 0100 0000。
在小端模式下，前16位應該這樣讀: 4e 6c 84 e6( 假設int佔4個位元組)。
記憶方法: 地址的增長順序與值的增長順序相同。
大小端模式：
為什麼會有大小端模式之分呢？這是因為在計算機系統中，我們是以位元組為單位的，每個地址單元都對應著一個位元組，一個位元組為 8bit。但是在C語言中除了8bit的char之外，還有16bit的short型，32bit的long型（要看具體的編譯器），另外，對於位數大於 8位的處理器。
例如16位或者32位的處理器，由於寄存器寬度大於一個位元組，那麼必然存在著一個如何將多個位元組安排的問題。因此就導致了大端存儲模式和小端存儲模式。例如一個16bit的short型x，在內存中的地址為0x0010，x的值為0x1122，那麼0x11為高位元組，0x22為低位元組。
對於 大端模式，就將0x11放在低地址中，即0x0010中，0x22放在高地址中，即0x0011中。小端模式，剛好相反。我們常用的X86結構是小端模式，而KEIL C51則為大端模式。很多的ARM，DSP都為小端模式。有些ARM處理器還可以由硬體來選擇是大端模式還是小端模式。
6. C語言程序怎樣判斷計算機的CPU大小端
寫一個C函數，若處理器是Big_endian的，則返回false；若是Little_endian的，則返回true。
boolIsLitte＿Endian()
{
union w{
int a;
char b;
}c;
c.a=1;
return (c.b==1);
}
7. 計算機中的大小端模式及C語言中如何鑒別他們
寫一個C函數，若處理器是Big_endian的，則返回false；若是Little_endian的，則返回true。boolIsLitte＿Endian() { union w{ int a; char b; }c; c.a=1; return (c.b==1); }
8. 大小端模式的判斷處理器
通過下列的程序可以確認在某個硬體平台上的某個操作系統是大端還是小端：
VB6： '注意這個CopyMemory的聲明與一般的不一樣，'一般的都是(pDstAsAny,pSrcAsAny,ByValByteLenAsLong)'為了能夠逐位元組訪問u，所以前面兩個參數改成了按值傳遞，配合VarPtr函數獲取變數地址_RtlMoveMemory(ByValpDstAsLong,ByValpSrcAsLong,ByValByteLenAsLong)PrivateSubForm_Load()'VB的Integer佔用2個位元組！Long才是4個位元組'32位應用程序的指針是4個位元組sLong'儲存u從低地址到高地址的4個位元組=367328153'十六進制數：15E4FB99uptr=VarPtr(u)'VarPtr函數是內置函數，但是msdn不說，作用是獲取變數的地址aptr=VarPtr(a)bptr=VarPtr(b)cptr=VarPtr(c)dptr=VarPtr(d)CopyMemoryaptr,uptr+0,1'將u逐位元組按順序寫入a,b,c,dCopyMemorybptr,uptr+1,1CopyMemorycptr,uptr+2,1CopyMemorydptr,uptr+3,1'Windows系統，英特爾處理器：最後輸出的是99FBE415MsgBoxHex(a)&&Hex(b)&&Hex(c)&&Hex(d)EndSub在英特爾處理器，Windows10操作系統上，對話框顯示的結果是99 FB E4 15，與直接求出來的16進制值15 E4 FB 99正好相反，所以是小端的。
C++語言（VS2013下，控制台項目）： #include<iostream>usingnamespacestd;typedefunsignedcharbyte;//轉換char（視為整數類型）為16進制字元串voidChtoHex(byteVal,char*dest){//輾轉相除法，倒序看得到結果bytetmp=Val%16;if(tmp>=0&&tmp<=9){dest[1]='0'+tmp;}elseif(tmp>=10&&tmp<=15){dest[1]='A'+tmp-10;}tmp=(Val/16)%16;if(tmp>=0&&tmp<=9){dest[0]='0'+tmp;}elseif(tmp>=10&&tmp<=15){dest[0]='A'+tmp-10;}//設置' 'dest[2]=' ';}//主函數intmain(){intu=367328153;//原始數據，8位16進制為15E4FB99bytea,b,c,d;//u從低地址到高地址的四個位元組//a~d對應的16進制字元串，預留3個字元charSa[3],Sb[3],Sc[3],Sd[3];byte*k=(byte*)&u;a=k[0];b=k[1];c=k[2];d=k[3];//轉成16進制字元串ChtoHex(a,Sa);ChtoHex(b,Sb);ChtoHex(c,Sc);ChtoHex(d,Sd);cout<<Sa<<<<Sb<<<<Sc<<<<Sd<<endl;system(pause);return0;}在英特爾處理器，Windows10操作系統上，控制台顯示的結果是99 FB E4 15，與直接求出來的16進制值15 E4 FB 99正好相反，所以也證明是小端的。
C語言（VC++6.0，控制台工程）： #include<stdio.h>typedefunsignedcharbyte;//轉換char（視為整數類型）為16進制字元串voidChtoHex(byteVal,char*dest){//輾轉相除法，倒序看得到結果bytetmp=Val%16;if(tmp>=0&&tmp<=9){dest[1]='0'+tmp;}elseif(tmp>=10&&tmp<=15){dest[1]='A'+tmp-10;}tmp=(Val/16)%16;if(tmp>=0&&tmp<=9){dest[0]='0'+tmp;}elseif(tmp>=10&&tmp<=15){dest[0]='A'+tmp-10;}//設置 dest[2]=' ';}//主函數voidmain(){intu=367328153;//原始數據，8位16進制為15E4FB99bytea,b,c,d;//u從低地址到高地址的四個位元組//a~d對應的16進制字元串，預留3個字元charSa[3],Sb[3],Sc[3],Sd[3];byte*k=(byte*)&u;a=k[0];b=k[1];c=k[2];d=k[3];//轉成16進制字元串ChtoHex(a,Sa);ChtoHex(b,Sb);ChtoHex(c,Sc);ChtoHex(d,Sd);printf(%s%s%s%s
,Sa,Sb,Sc,Sd);scanf_s(%d,&a);}在英特爾處理器，Windows10操作系統上，結果跟上面是一樣的，輸出的16進制數是反序的，證明是小端系統。
C#（VS2013下，控制台項目）： usingSystem;namespaceConsoleApplication1{classProgram{staticvoidMain(string[]args){intu=367328153;//原始數據，8位16進制為15E4FB99byte[]bytes;//u從低地址到高地址的四個位元組//獲取bytes=System.BitConverter.GetBytes(u);Console.WriteLine(bytes[0].ToString(X)++bytes[1].ToString(X)++bytes[2].ToString(X)++bytes[3].ToString(X));Console.ReadLine();}}}在英特爾處理器，Windows10操作系統上，結果跟上面還還是一樣的，輸出的16進制數是反序的，證明是小端系統。
MDK（Keil5，STM32F407）C語言： #includestm32f4xx.hintmain(void){intu=367328153;//原始數據15E4FB99int*k=&u;return0;}編譯連接然後下載到開發板上，然後啟動調試，通過監視窗口可以看到u的地址，然後在內存窗口可以看到位元組序是反序的，所以說明STM32F407是小端的。據某些資料說ARM內核是可以設置大小端的，但是STM32是外設自動進入了小端，似乎是無法調整的。
89C52（Keil5）C語言：
最後來一個大端的例子。手頭上沒有51的開發板，所以用的是軟體模擬。 #include<reg52.h>intmain(){intlongbit=sizeof(long);longu=367328153;//原始數據15E4FB99long*k=&u;return0;}注意看了，C52是8位的處理器，long才是4個位元組的，看監視窗口longbit的值就知道了（紫色框）。然後再看內存窗口，就會發現u的存儲是跟原始數據給的順序是一樣的，所以C51和C52是大端的！！
9. C語言讀寫二進制文件讀取 大小端，該怎麼解
先看下面的代碼，然後我在簡短的解釋一下。
#include <stdio.h>#include <stdlib.h>#include <string.h>#include <string>#define nmemb 7/****************************************************Date types(Compiler specific) 數據類型（和編譯器相關）
*****************************************************/typedef unsigned char uint8; /* Unsigned 8 bit quantity */typedef signed char int8; /* Signed 8 bit quantity */typedef unsigned short uint16; /* Unsigned 16 bit quantity */typedef signed short int16; /* Signed 16 bit quantity */typedef unsigned int uint32; /* Unsigned 32 bit quantity */typedef signed int int32; /* Signed 32 bit quantity */typedef float fp32; /* Single precision */
/* floating point */typedef double fp64; /* Double precision */
/* floating point *///int32#define BigtoLittle32(A) ((( (uint32)(A) & 0xff000000 ) >> 24) |
(( (uint32)(A) & 0x00ff0000 ) >> 8) |
(( (uint32)(A) & 0x0000ff00 ) << 8) |
(( (uint32)(A) & 0x000000ff ) << 24))//int16#define BigtoLittle16(A) (( ((uint16)(A) & 0xff00) >> 8 ) |
(( (uint16)(A) & 0x00ff ) << 8))/************************************************************
* Conversion little endian float data to big endian
* *************************************************************/float ReverseFloat(const float inFloat)
{ float retVal; char *floatToConvert = (char*) & inFloat; char *returnFloat = (char*) & retVal; // swap the bytes into a temporary buffer
returnFloat[0] = floatToConvert[3];
returnFloat[1] = floatToConvert[2];
returnFloat[2] = floatToConvert[1];
returnFloat[3] = floatToConvert[0]; return retVal;
}struct matrix
{ int row; int column;
}s[nmemb];void set_s(int j, int x, int y)
{
s[j].row = x;
s[j].column = y;
}bool is_bigendian()
{ int a = 0x1234; char b = *(char *)&a; //b == the Low address part of a
//printf("%c ", b);
if (b == 0x34) { return false;
} return true;
}int main()
{ if (is_bigendian()) { printf("BigEndian ");
} else { printf("LittleEndian ");
}
FILE *fp;
set_s(0, 1, 50);
set_s(1, 1, 80);
set_s(2, 4, 20);
set_s(3, 50, 1);
set_s(4, 80, 2);
set_s(5, 100, 3);
set_s(6, 100, 4); int ans = sizeof(struct matrix); printf("size: %d ", ans); printf("size: %d ", sizeof(s)); if ((fp = fopen("test", "wb")) == NULL) { printf("EROOR "); return 1;
} for (int j = 0; j < nmemb; ++j) { printf("row: %d column: %d ", s[j].row, s[j].column);
}
fwrite(s, sizeof(struct matrix), nmemb, fp); for (int i = 0; i < nmemb; ++i) { float *m = (float*) malloc(sizeof(float) * s[i].row * s[i].column);
bzero(m, sizeof(float) * s[i].row * s[i].column); for (int j = 0; j < s[i].row; ++j) { for (int k = 0; k < s[i].column; ++k) {
m[k + j*s[i].column] = k;
}
}
fwrite(m, sizeof(float), s[i].row * s[i].column, fp); free(m);
}
fclose(fp); printf("11 "); /*
printf("%d ", sizeof(float));
FILE *fp;
if ((fp = fopen("test", "rb")) == NULL) {
printf("EROOR ");
return 1;
}
fread(s, sizeof(struct matrix), nmemb, fp);
for (int i = 0; i < nmemb; ++i) {
printf("row: %d column: %d ", s[i].row, s[i].column);
}
for (int i = 0; i < nmemb; ++i) {
float *m = (float*) malloc(sizeof(float) * s[i].row * s[i].column);
bzero(m, sizeof(float) * s[i].row * s[i].column);
fread(m, sizeof(float), s[i].row * s[i].column, fp);
for (int j = 0; j < s[i].row; ++j) {
for (int k = 0; k < s[i].column; ++k) {
printf("%lf ", m[k + j*s[i].column]);
}
printf(" ");
}
printf(" ");
free(m);
}
fclose(fp);
*/
return 0;
}
fopen和fclose是很常見的，在這里就不做解釋了。我們來看看fwrite和fread，本來以為這個很麻煩，但是用過之後發現這個二進制文件讀寫才是最簡單的。
size_t fwrite(const void * ptr,size_t size,size_t nmemb,FILE * stream);
fwrite()用來將數據寫入文件流中。
stream為已打開的文件指針
ptr 指向欲寫入的數據地址
寫入的字元數以參數size*nmemb來決定。
size表示寫入一個nmemb的內存大小。
fwrite()會返回實際寫入的nmemb數目。
size_t fread(void * ptr,size_t size,size_t nmemb,FILE * stream);
fread()用來從文件流中讀取數據。
stream為已打開的文件指針
ptr 指向欲存放讀取進來的數據空間
讀取的字元數以參數size*nmemb來決定
size表示讀取一個nmemb的內存大小。
fread()會返回實際讀取到的nmemb數目，如果此值比參數nmemb 小，則代表可能讀到了文件尾或有錯誤發生，這時必須用feof()或ferror()來決定發生什麼情況。
返回實際讀取到的nmemb數目。
詳情參見上面的代碼。
另外就是大小端的問題了。關於大小端的具體解釋網上有很多，在此不作解釋。參考上面寫的代碼，我判斷了自己機器是大端還是小端，並且實現了int16，int32已經float數據類型的大小端轉換，大端轉小端，在使用相同的代碼一次小端又變成了大端。
PS：float的大小端轉化我之前一直以為寫的是錯的，因為好多數據轉化之後輸出都是0。後來發現可能是與float類型在內存中的存放有關，我們的程序是對的。
10. C語言中使用union是怎麼判斷處理器大小端的
union Charge
{
char arr[2];
short num;
};
int main()
{
union Charge charge;
charge.arr[0] = 1;
charge.arr[1] = 2;
if (charge.num == 0x0201)
{
printf("小端\n");
}
else
{
printf("大端\n");
}
return 0;
}