嵌入式C语言基础（三）

字符串的定义方式及输出：

#include <stdio.h>
#include <stdlib.h>
void strPrint(char* data,int size)
{int i;for(i=0;i<size;i++){printf("函数打印数组：%c\n",*data++);}putchar('\n');
}
int main()
{int i=0;int a[3]={1,2,3};char c='a';//第一种方式：char str[5]={'a','b','c','d','e'};//定义字符串并进行初始化,类比于整数数组很土strPrint(str,sizeof(str)/sizeof(str[0]));//第二种方式：char str2[5]="fghij";//写在一起的时候就不用大括号了strPrint(str2,sizeof(str2)/sizeof(str2[0]));//第三种方式//char str3[]={'k','l','m'};char str3[]="klm";//数组大小不写，但会根据元素个数默认分配//sizeof计算时会大一个字节，因为将字符串的结束标志\0，算入了strPrint(str3,sizeof(str3)/sizeof(str3[0])-1);//第四种方式：指针方式,操作不当,内存非法，会造成段错误（sigment error）char* pstr="hello world!";//字符串的最好的定义方式，pstr可以理解为数组的地址(大多数情况下，数组名就是地址)。printf("%s\n",pstr);//字符串用占位符%s表示，不需要用i的下标遍历system("pause");return 0;
}

字符串在内存中的存储方式：

#include <stdio.h>
#include <stdlib.h>
//字符存储方式：字符串在内存中，除了有效字符外，还会自动在后面补一个\0作为字符串结束的标志
//真正计算有效字符的长度用strlen
int main()
{int a[]={1,2,3};//连续的空间，整个数组的的大小是元素个数*元素类型的大小printf("a数组的大小是：%d\n",sizeof(a));printf("a数组一项元素的大小是：%d\n",sizeof(a[0]));printf("a数组的个数是：%d\n",sizeof(a)/sizeof(a[0]));putchar('\n');//字符串的存储方式char c[]={'a','b','c'};printf("c数组的大小是：%d\n",sizeof(c));printf("c数组一项元素的大小是：%d\n",sizeof(c[0]));printf("c数组的个数是：%d\n",sizeof(c)/sizeof(c[0]));putchar('\n');char e[3]="abc";printf("e数组的大小是：%d\n",sizeof(e));printf("e数组一项元素的大小是：%d\n",sizeof(e[0]));printf("e数组的个数是：%d\n",sizeof(e)/sizeof(e[0]));putchar('\n');//在定义的时候不写元素个数，数组会在初始化的时候根据元素个数确定数组的大小char d[]="abc";//这种方式计算的数组大小会偏大一个字节，因为有字符串结束的标志\0printf("d数组的大小是：%d\n",sizeof(d));printf("d数组一项元素的大小是：%d\n",sizeof(d[0]));printf("d数组的个数是：%d\n",sizeof(d)/sizeof(d[0]));//printf("d[3]:%c",d[3]);//第三格元素是\0打印不出来putchar('\n');//利用while循环输出int i=0;while(d[i]!='\0'){printf("while循环打印:%c",d[i]);i++;putchar('\n');}char k='a';printf("字符的大小是：%d\n",sizeof(k));system("pause");return 0;
}

sizeof和strlen区别：

#include <stdio.h>
#include <stdlib.h>
/*
计算字符串中字符的个数不能用sizeof来计算字符串中有效字符的个数！！！！应该要用strlen(),strlen()在计算字符串大小的时候，遇到\0后就结束计数比如：strlen(hello\0world)=5而sizeof(hello\0w)=8*/
int main()
{int a[]={1,2,3};printf("数组a的元素个数：%d\n",sizeof(a)/sizeof(a[0]));char a2[]="hello";printf("数组a2元素个数：%d\n",sizeof(a2)/sizeof(a2[0]));//输出6printf("strlen输出:%d\n",strlen(a2));char a3[128]="hello";//其他123个是\0printf("数组a3元素个数：%d\n",sizeof(a3)/sizeof(a3[0]));//输出128printf("strlen输出:%d\n",strlen(a3));system("pause");return 0;
}

字符串操作常用的API：
API是函数调用的接口，通俗来讲就是函数。

这个是我对上面第四种方式定义字符串的理解：

#include <stdio.h>
#include <stdlib.h>
//puts()函数,printf(); 在输出数据的时候，遇到 ‘\0’ 就会结束输出。
/*数组名本身就是地址，指针数组的数组名作为地址又存放指针
用法和二级指针相似但是不是二级指针，sizeof(数组名)和sizeof(指针)不一样*/
int main()
{char* a1[]={"hello","world"};//ai[0]=hello,a1[1]=world,hello和world都是指针//hello在这里是指针,作为数组中的元素printf("a1的大小是：%d\n",sizeof(a1));//这里输出8，因为数组中有两个指针，在啊哈C这个编译器下指针大小为4个字节printf("a1输出：%p\n",a1);//输出的是指针数组的地址，也是第一个指针的地址printf("a1输出：%p\n",&a1[0]);//**a1++;//a1是常量不能++printf("a1输出：%s\n",*a1);//输出的是hello，因为a1既是数组名又是第一个指针的地址,*a1就是指针本身就是hello,%s可以输出指针printf("a1输出：%c\n",**a1);//输出的是h因为*a1是hello,可以把hello当做数组，所以**a1就是去第一个元素的内容为h。printf("a1输出：%c\n",(*a1)[0]);//等同于**a1,把hello当做数组，把*a1当做数组名，只是当做而已printf("a1输出：%c\n",(*a1)[1]);//取hello这个数组的第二个元素char* a2="hello";printf("a2输出：%s\n",a2);//a2是指针用%s可以直接输出指针对应的字符串printf("a2输出：%c\n",*a2);//把指针a2看做数组名,*a2就是第一个元素的地址，所以*a2就是hprintf("a2输出：%c\n",a2[1]);//把指针a2看做数组名，所以输出eprintf("a2输出：%c\n",*(a2+2));//将指针向后偏移一位后取内容就是lprintf("a2输出：%p\n",&a2[0]);//这是第一个元素的地址printf("a2输出：%p\n",a2);//这个是指针，看成数组的话就是第一个元素的地址和&a2[0]输出结果一样/*int* a3[]={1,2,3};//1,2,3在这里是指针，但是不能那么用，容易造非法内存访问*/system("pause");return 0;
}

puts、gets、memset

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//puts()会自动在输出后加\n
//而printf()需要手动输入
//gets()获取一个字符串
//getchar()和putchar()操作对象是字符
int main()
{char* str="哈喽！";printf("%s\n",str);puts(str);//char pstr[128]={'\0'};//1、申请空间2、初始化，把每一个元素都初始化为\0char* str2;//野指针 造成非法内存访问 会出现段错误str2=NULL;str2=(char*)malloc(3);//申请空间if(str2==NULL){printf("申请失败\n");exit(-1);//exit表示退出这个进程，-1表示异常退出    }memset(str2,'\0',3);//初始化，将每个元素初始化为\0/*memset第一个参数是：你要初始化的对象(空间)第二个参数是初始化成什么第三个参数是初始化多大*//* 一旦用了malloc就要注意内存泄露的问题，malloc可能会失败，要对返回值做判断,若开辟的内存==NULL，表示开辟失败*/printf("请输入字符串：\n");//scanf("%s",str2);gets(str2);puts(str2);system("pause");return 0;
}

strcpy、strncpy、strcmp、strcat

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//汉字所占字节：这和编码有关，UTF8一个汉字占3个字节，GBK一个汉字占2个字节。
/*
strcpy:字符串复制函数
函数原型是：char *strcpy(char* dest, const char *src);
功能：把从src地址开始且含有NULL结束符的字符串复制到以dest开始的地址空间
说明：src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。
返回指向dest的指针。strncpy:函数用于将指定长度的字符串复制到字符数组中
函数原型：char *strncpy(char *destinin, char *source, int maxlen);
destinin：表示复制的目标字符数组；
source：表示复制的源字符数组；
maxlen：表示复制的字符串长度。
source串长度<=destin串长度(这里的串长度包含串尾NULL字符)
①如果n<source由于长度达到source NULL，正常复制，
如果source中有NULL，strncpy复制到NULL即使没到n也提前停止，
注意n的选择当n > destin串长度，destin栈空间溢出产生崩溃异常。
②source串长度>destin串长度
如果n =destin串长度，则destin串没有NULL字符，会导致输出会有乱码。
如果不考虑source串复制完整性，可以将destin 最后一字符置为'\0'。strcat:将两个char类型连接。
注意：d和s所指内存区域不可以重叠且d必须有足够的空间来容纳s的字符串。
拼接后两个字符串之间无空格，返回指向d的指针。
函数原型：extern char *strcat(char *dest, const char *src);*//*
字符串比较函数：strcmp()
函数原型：extern int strcmp(const char *s1,const char *s2);
两个字符串自左向右逐个字符相比（按ASCII值大小相比较），直到出现不同的字符或遇'\0'为止。特别注意：strcmp(const char *s1,const char * s2)这里面只能比较字符串，
即可用于比较两个字符串常量，或比较数组和字符串常量，不能比较数字等其他形式的参数。
用于比较两个字符串长度并根据比较结果返回整数。
基本形式为strcmp(str1,str2)，若str1=str2，则返回零；
若str1<str2，则返回负数；若str1>str2，则返回正数。
当两个字符串不相等时，C标准没有规定返回值会是1 或 -1，只规定了正数和负数。
有些会把两个字符的ASCII码之差作为比较结果由函数值返回。但无论如何不能以此条依据作为程序中的流程逻辑。
*//*那什么操作会引起段错误呢?1、往受到系统保护的内存地址写数据，有些内存是内核占用的或者是其他程序正在使用，为了保证系统正常工作，所以会受到系统的保护，而不能任意访问。2、内存越界(数组越界，变量类型不一致等)3、其他例如：<1>定义了指针后记得初始化，在使用的时候记得判断是否为NULL<2>在使用数组的时候是否被初始化，数组下标是否越界，数组元素是否存在等<3>在变量处理的时候变量的格式控制是否合理等内存泄漏：内存泄露 memory leak，是指程序在申请内存后，无法释放已申请的内存空间，一次内存泄露危害可以忽略，但内存泄露堆积后果很严重，无论多少内存,迟早会被占光。最终的结果就是导致OOM。内存泄漏是指你向系统申请分配内存进行使用(malloc)，可是使用完了以后却不归还(free)，结果你申请到的那块内存你自己也不能再访问（也许你把它的地址给弄丢了），而系统也不能再次将它分配给需要的程序。一般我们常说的内存泄漏是指堆内存的泄漏。堆内存是指程序从堆中分配的，大小任意的（内存块的大小可以在程序运行期决定），使用完后必须显示释放的内存。应用程序一般使用malloc，realloc，new等函数从堆中分配到一块内存，使用完后，程序必须负责相应的调用free或delete释放该内存块，否则，这块内存就不能被再次使用，我们就说这块内存泄漏了。   内存溢出：内存溢出 OOM （out of memory），是指程序在申请内存时，没有足够的内存空间供其使用，出现out of memory；比如申请了一个int,但给它存了long才能存下的数，那就是内存溢出。
*/
int main()
{char* strSrc="hello!";char* dest;dest=(char*)malloc(12);memset(dest,'\0',12);puts(strcpy(dest,strSrc));//若再srecpy会将之前的内容覆盖掉char strdest[3]={'\0'};//可以将数组初始化strcpy(dest,"he");//会将之前的内容覆盖掉，输出heputs(dest);memset(strdest,'\0',sizeof(strdest)/sizeof(strdest[0]));//这个也可以将数组初始化strncpy(strdest,strSrc,6);//注意n的选择当n > destin串长度，destin栈空间溢出产生崩溃异常。strdest[2]='\0';//将第三个元素赋值为\0,初始化的时候要用{}printf("strdest长度为：%d\n",strlen(strdest));puts(strdest);char* dest1;dest1=(char*)malloc(128);//malloc向内存申请了128个字节//dest1是访问这片内存的唯一方式，若这个指针指向了别的地址//那么这片内存在程序释放之前不会被释放造成内存泄漏if(dest1==NULL){printf("开辟失败！\n");}memset(dest1,'\0',128);free(dest1);//释放开辟的指针//dest1="hello world";//如果这里写如这段代码，dest1本来指向malloc开辟的内存空间//然而这段代码又将dest1指向了字符串,造成了malloc开辟的空间无指针指向，造成内存泄露//又双引号引起来的字符串叫字符串常量，不可变，只能进行读操作不能进行写操作，否则将会出现段错误//段错误应该就是访问了不可访问的内存，这个内存区要么是不存在的，要么是受到系统保护的//这里就是因为写入了这段代码，造成了内存泄漏和段错误，找了半天错误char dest2[128]="hello world";                     strcat(dest2, strSrc);puts(dest2);char *str1="123";//如果不同，在不同的字符处如果str1的字符大于str2的字符，则返回1，否则返回-1char *str2="12345";printf("若输出负数表示str1比str2小，反之则大，相等则输出0：%d\n",strcmp(str1,str2));system("pause");return 0;
}

strchr、strstr、strlwr、strupr、strtok

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/*
strchr函数:
函数原型：char *strchr(const char *str, int c)
参数：要被检索的 C 字符串。在 str 中要搜索的字符。大小写也有区分
功能：在参数str所指向的字符串中搜索第一次出现字符c（一个无符号字符）的位置。
返回值：返回一个指向该字符串中第一次出现的字符的指针，如果字符串中不包含该字符则返回NULL空指针。
*//*
strstr函数：
strstr(str1,str2) 函数用于判断字符串str2是否是str1的子串。
如果是，则该函数返回 str1字符串从 str2第一次出现的位置开始到 str1结尾的字符串；否则，返回NULL。
函数原型：char* strstr( char*str,char* substr)------字符串也是指针
功能：strstr返回一个指针，指向substr在str中首次出现的位置。*//*
strlwr函数：
原型：extern char *strlwr(char *s);
功能：将字符串s参数转换为小写形式
说明：只转换s参数中出现的大写字母，不改变其它字符。返回指向s参数的指针。
兼容性说明：strlwr和strupr不是标准C库函数，只能在VC中使用。linux gcc环境下需要自行定义这个函数。
*//*
strupr:将字符串s转换为大写形式。
函数原型：extern char *strupr(char *s);
说明：只转换s中出现的小写字母，不改变其它字符。返回指向s的指针。
兼容性说明：strupr不是标准C库函数，只能在VC中使用。在linux gcc环境下需要自行定义这个函数。
*//*
strtok()函数:
函数原型：char *strtok(char *str, const char *delim)
str -- 要被分解成一组小字符串的字符串。
delim -- 包含分隔符的 C 字符串。
功能：作用于字符串s，以delim中的字符为分界符，将s切分成一个个子串；
如果，s为空值NULL，则函数保存的指针SAVE_PTR在下一次调用中将作为起始位置。
返回值：该函数返回被分解的第一个子字符串，如果没有可检索的字符串，则返回一个空指针。*/
void strtokPrint(char*p)
{int i=1;int j=0;char* psubs[3];//定义一个指针数组，将分割好的字符串存入const char str7[]=",";char* p1=NULL;p1=strtok(p,str7);while(p1!=NULL){printf("第%d次分割为：%s\n",i,p1);psubs[i-1]=p1;//将分割好的第一个字符串存入指针数组p1=strtok(NULL,str7);if(p1==NULL)break;i++;}for(j;j<i;j++){printf("输出分割后的指针是：%s\n",psubs[j]);}
}
int main()
{char c='e';char* str="hello";char* ret=NULL;ret=strchr(str,c);//只可用来查找字符if(ret==NULL){printf("没有找到\n");}printf("手动输出的h的地址是；%p\n",str);printf("找到了strchr输出的h的地址是；%p,字符是；%s\n",ret,ret);/*这里找到目标字符的地址后若用%s进行输出，则将目标字符看做字符串的首地址会将目标字符后的字符串输出，若指向输出目标字符得取地址*ret*/char* str2="hello";char* str3="he";puts(strstr(str2,str3));//输出的是hello,返回的是h的地址/*char* str4="HELLO";    puts(strlwr(str4));这种方式在linux环境下是可以的，在windows下会闪退所以换下一种字符串定义的方式(数组的形态)*/char str4[]="HELLO";puts(strlwr(str4));char str5[]="hello";//在windows下用法和strlwr一样  puts(strupr(str5));//和strlwr一样参数不能是字符，否则出现段错误char str6[]="feng,nan,nan,";//在windows下用法和strlwr一样char* p=NULL;   /*const char str7[]=",";//,占用2个字节要用双引号p=strtok(str6,str7);//注意这里分隔符要用双引号if(p!=NULL){printf("第一次输出：%s\n",p);}puts(str6);//特别要注意分割处理后原字符串str6会变，变成第一个子字符串feng//获取第二个字符串的时候要将目标字符串改成NULLp=strtok(NULL,",");if(p!=NULL){printf("第二次输出：%s\n",p);}puts(str6);//特别要注意分割处理后原字符串str6会变，变成第一个子字符串，仍然是fengp=strtok(NULL,",");//获取第三个字符串也是同样的道理if(p!=NULL){printf("第三次输出：%s\n",p);}puts(str6);以上代码可优化为函数*/strtokPrint(str6);puts(str6);//因为传入的是数组名相当于指针，所以原数组分割处理后原字符串str6会变，变成第一个子字符串，仍然是fengsystem("pause");return 0;
}

自己实现puts、gets、memset、strlen

#include <stdio.h>
#include <stdlib.h>
//实现puts函数
void myPuts(char* p)
{     //字符串明显的特点是：结尾有'\0'while(*p!='\0'){putchar(*p++);//printf("%c",*p++);}putchar('\n');
}
//自己实现字符串的输入函数
void myGets(char* p)
{if(p==NULL){printf("内存非法");return;//执行到return后函数不继续向下执行}while(*p=getchar()){//赋值不是空字符就是真，是空字符就都是假if(*p=='\n'){return;}else{p++;}}
}
//修改myGets计算用户输入字符个数
int cntGets(char* p)
{int cnt=0;if(p==NULL){printf("内存非法");return;//执行到return后函数不继续向下执行}while(*p=getchar()){if(*p=='\n'){return cnt;}else{cnt++;p++;}}
}
//自己实现strlen函数
void myStrlen(char*p)
{int cnt=0;/*while(*p!='\0'){  cnt++;p++;}*/while(*p++!='\0'){//先执行*p然后再++再*p  cnt++;}printf("字符串长度是：%d",cnt);putchar('\n');
}
//自己实现memset函数
void myMemset(char*p,char a,int n)
{while(n){*p++=a;n--;        }
}
int main()
{char str[128]={'\0'};char* p="hello!";myPuts(p);myPuts("请输入你的字符串:");int ret=cntGets(str);printf("你输入了%d个字符\n",ret);myStrlen(p);char* str1=NULL;str1=(char*)malloc(128);myMemset(str1,'a',128);str1[128]='\0';myPuts(str1);system("pause");return 0;
}

自己实现srtcpy、strncpy、strcat、strcmp、strchr、strstr、strlwr、strupr、strtok

#include <stdio.h>
#include <stdlib.h>
//实现strcpy,拷贝函数是将前面的全覆盖掉
char* myStrcpy(char*data1,const char*data2)//源字符串参数用const修饰，防止修改源字符串。
{if(data1==NULL||data2==NULL){return NULL;}char* p=data1;//将data1的首地址给p，等返回时就会返回data1的首地址while((*data1++=*data2++)!='\0'){//*data1++=*data2++;}return p;//拷贝完成后指针在data1的末尾//返回目的地址，是为了实现链式操作
}//自己实现strncpy(),拷贝的是第二个字符串的前n个字符，前一个字符串的后面部分不变
char * myStrncpy(char*data1,char*data2,int n)
{if(data1==NULL||data2==NULL){return NULL;}char*p=data1;int i=0;for(i;i<n;i++){*data1=data2[i];data1++;}/*while(*data2!='\0' && n>0){*data1++=*data2++;n--;}  */return p;
}//自己实现字符串的拼接函数strcat()
char* myStrcat(char*data1,char*data2)
{if(data1==NULL||data2==NULL){return NULL;}char*p=data1;while(*data1!='\0'){//若括号里写*data1++!='\0'则在等于‘\0’后还会++一次data1++;}   while(*data2!='\0'){*data1++=*data2++;}return p;
}//自己实现字符串比较函数strcmp()
int myStrcmp(const char* data1,const char* data2)
{if(data1==NULL||data2==NULL){return NULL;}while ((*data1) && (*data1 == *data2))//判断有没有到结尾和是否相等 {  data1++;  data2++;  }  if (*data1 > *data2)  {  return 1;  }  else if (*data1 < *data2)  {  return -1;  }  else  {  return 0;  }
}
//自己实现字符查找函数strchr
char *myStrchr(const char *s,char c)  //返回的是你要找的字符的地址
{for(;*s!=c;s++){if(*s == '\0')  //说明找完了return NULL;//找完了还没有。那就直接返回空咯}return s;//我们须要的字符的地址
}
/*
char * Strchr(char to[], char Ch)
{int i = 0;while (to[i] != Ch && to[i] != '\0')i++;return to[i] != '\0'?to + i : NULL;
}
*///自己实现strstr函数
const char* myStrstr(const char* src, const char* sub)
{const char *bp;const char *sp;if(!src || !sub){return src;}/* 遍历src字符串  */while(*src){/* 用来遍历子串 */bp = src;sp = sub;do{if(!*sp)  /*到了sub的结束位置，返回src位置   */return src;}while(*bp++ == *sp ++);src ++;}return NULL;
}//自己实现strlwr函数
char* myStrlwr(char*data)
{char*p=data;while (*data!= '\0'){if (*data > 'A' && *data <= 'Z'){//*src += 0x20; *data += 32;}data++;}return p;
}
//自己实现strupr函数
char* myStrupr(char* data)
{char*p=data;while (*data != '\0'){if (*data >= 'a' && *data <= 'z'){//在ASCII表里大写字符的值比对应小写字符的值小32.//*p -= 0x20; // 0x20的十进制就是32*data -=32;}data++;}return p;}
//自己实现strtok函数
char *myStrtok(char *str,char *demion)
{static char *p_last = NULL;if(str == NULL && (str = p_last) == NULL){return NULL;}   char *s = str;char *t= NULL;while(*s != '\0'){t= demion;while(*t != '\0'){if(*s == *t){p_last  = s +1;if( s - str == NULL){str = p_last;break;}*s = '\0';return str;}t++;}s++;}return NULL;
}
int main()
{char dest[128]="HELLO hello!";//char* dest=NULL;char* src="HELLO hello!";//字符串常量不可被修改，只读char* a=" ";//puts(strcpy(dest,src));//printf("长度为：%d\n",strlen(myStrcpy(dest,src)));//返回目的地址，是为了实现链式操作//puts(myStrcpy(dest,src));//若没有返回值，不能将这段代码直接写入puts中，因为返回的是在data1末尾的指针，无输出//puts(myStrncpy(dest,src,3));//puts(myStrcat(dest,src));//int ret=myStrcmp(dest,src);//printf("输出：%d\n",ret);//puts(myStrstr(dest,src));//puts(myStrlwr(dest));puts(myStrupr(dest));puts(myStrtok(dest,a));//输出HELLO//puts(myStrchr(src,'e'));system("pause");return 0;
}

指针补充：
字长：在同一时间中处理二进制数的位数叫字长。通常称处理字长为8位数据的CPU叫8位CPU，32位CPU就是在同一时间内处理字长为32位的二进制数据。二进制的每一个0或1是组成二进制的最小单位,称为一个比特（bit）

指针的大小与什么有关？1、cpu位数（32位数4字节，64位数8字节）
2、操作系统位数（32位数4字节，64位数8字节）
3、编译器的位数（32位数4字节，64位数8字节）

4、字长由微处理器（CPU）对外数据通路的数据总线条数决定。　　
5、最小可寻址单位：内存的最小可寻址单位通常都是字节。也就是说一个指针地址值可对应内存中一个字节的空间。
6、寻址空间：寻址空间一般指的是CPU对于内存寻址的能力。CPU最大能查找多大范围的地址叫做寻址能力，CPU的寻址能力以字节为单位（字节是最小可寻址单位）。如32位寻址的CPU可以寻址2的32次方大小的地址也就是4G，这也是为什么32位寻址的CPU最大能搭配4G内存的原因，再多的话CPU就找不到了。
7、这里CPU的寻址位数是由地址总线的位数决定，32位CPU的寻址位数不一定是32位，因为32位CPU中32的意义为字长。
8、有关寻址范围计算解释，对于32位寻址的CPU，其地址值为32位的二进制数，所以可以表示的最大地址为2的32次方(即4G，最大内存空间为4GB，这里G表示数量、GB表示容量)。同时我们不难看出，一个指针的值就是一个32位的二进制数，32位对应4字节(Byte)。所以，指针的大小实际上是由CPU的寻址位数决定，而不是字长。
指针大小有关因素详解：影响指针大小的因素

嵌入式C语言基础（三）相关推荐

嵌入式C语言基础（一）
嵌入式C语言基础: system函数:功能是运行windows命令 #include <stdio.h> #include <stdlib.h> int main() {//m ...
[GO语言基础] 三.变量声明、数据类型、标识符及编程练习12题
作为网络安全初学者,会遇到采用Go语言开发的恶意样本.因此从今天开始从零讲解Golang编程语言,一方面是督促自己不断前行且学习新知识:另一方面是分享与读者,希望大家一起进步.前文介绍了Go的编译运行 ...
# 工欲善其事必先利其器-C语言拓展--嵌入式C语言（三）
工欲善其事必先利其器-C语言拓展–嵌入式C语言(三) typeof() 使用typeof可以获取一个变量或表达式的类型. typeof的参数有两种形式:表达式或类型. int i;typeof(i) ...
嵌入式 C 语言中三块难啃的硬骨头
我是小麦,一名热爱学习的嵌入式工程师关注我,一起变得更加优秀! C语言在嵌入式学习中是必备的知识,审核大部分操作都要围绕C语言进行,而其中有三块"难啃的硬骨头"几乎是公认级别的. ...
嵌入式C语言基础知识梳理
该图是关于C语言基础知识的树状结构图,也许里面有些地方看起来不够主流,但是可能更合理.以后将会对该图的所有细节知识点以通俗易懂的方式逐个梳理,敬请关注!
嵌入式C语言基础教程一
嵌入式系统C语言编程--背景嵌入式系统C语言编程修炼之道--软件架构 ...
c语言入门敲打,C语言基础三（敲打键盘、寻找资料，循环语句）
有人在学C语言或者其他语言的时候,大家都会说逻辑思维的硬道理,认为没有逻辑思维的人走不远,那么小编这里借助简单的if...else... 英文解释if(如果),else(否则) ----------- ...
嵌入式C语言基础知识查漏补缺--内存管理函数指针数组
内存管理: 堆和栈的理解和区别局部变量静态局部变量全局变量静态全局变量作用域在定义变量的{}之内有效在定义变量的{}之内有效整个工程,所有文件当前文件生命周期程序运行至变量定义处 ...
DSP嵌入式C语言状态机,三段式状态机描述及模版
三段式状态机描述及模版 [复制链接] 本帖最后由 Aguilera 于 2018-11-10 20:23 编辑时序电路的状态是一个状态变量集合,这些状态变量在任意时刻的值都包含了为确定电路的未来行为 ...

嵌入式C语言基础（三）

嵌入式C语言基础（三）相关推荐

最新文章

热门文章