【c1】数据类型,运算符/循环,数组/指针,结构体,main参数,static/extern,typedef

05-13 1114阅读

文章目录

  • 1.数据类型:编译器(compiler)与解释器(interpreter),中文里的汉字和标点符号是两个字节,不能算一个字符(单引号)
  • 2.运算符/循环:sizeof/size_t
  • 3.数组:存数据类型相同的数据,数组下标越界导致段错误
  • 4.指针:指针数组:这个数组的所有元素都是指针类型。数组指针:这个指针存放着一个数组的首地址
    • 4.1 地址/值/变量名:p是地址,*p是指向的内容,01指0x01,&a:拿变量a的地址赋给
    • 4.2 函数调用:复制a/指向a
    • 4.3 函数返回:复制指针
    • 4.4 数组和指针转换:指针转不了数组,数组可转为指针,&取地址
    • 4.5 字符串str相关:putchar('w');putchar('w');
    • 5.结构体:存放一组不同数据类型的数据
    • 6.main函数的参数:main函数的参数是从命令提示符下执行程序时传入
    • 7.static/inline/回调/extern/堆内存:inline内联函数本身就是static(本文件私有)函数,inline函数在c中作用性不高,c中用习惯了宏定义
    • 8.typedef:define仅仅是简单的字符串的替换,而typedef则给这个类型新起了一个名字
      • 8.1 给已定义的变量类型起个别名:给struct __person起了个别名person_t
      • 8.2 定义函数指针类型:必须用typedef,方法就是在“定义函数指针变量”前加上typedef
      • 8.3 定义数组指针类型:先看如何定义数组指针变量
      • 8.4 定义数组类型:声明一个含5个int元素的一维数组:int a[5]

        1.数据类型:编译器(compiler)与解释器(interpreter),中文里的汉字和标点符号是两个字节,不能算一个字符(单引号)

        编译型语言:C/C++/golang/rust:并且都是AOT(ahead of time)预先编译,编译将源码编译成机器码生成二进制文件,可直接运行该文件,因为是机器码,所以运行效率很高。缺点:不够灵活,改代码要重新编译,此外平台依赖,linux平台编译出来的二进制文件无法在windows运行,跨平台还需借助交叉编译。

        解释型语言:python/js/php:不需要生成二进制文件,灵活如线上php系统,改了代码功能直接生效,但运行效率低。

        半解释半编译型语言:java:JIT将运行到的代码块在运行时编译成机器码,既可保证跨平台性,又能使热代码高效运行。

        C库函数声明头文件(.h):存放在/usr/include目录中,如果 #include ,则cJSON.h在/usr/include/facebook/目录里。如下github上软件包(devtool search),在image.bb中添加hiredis软件包查找hiredis.bb文件【内容有git网址】在yocto或common或meta-aspeed或meta-phosphor文件夹中,.h文件会在/usr/include/中,但rootfs中看不到。

        【c1】数据类型,运算符/循环,数组/指针,结构体,main参数,static/extern,typedef

        C库函数定义(具体实现)文件(.c):gcc编译不用包含libgcc.a(缺省会包含),/usr/lib/gcc/x86_64…/4.4.4/libgcc.a(打包好的静态库)。

        gcc main.c int_sum.c float_sum.c    -o main -Wall(显示所有警告)    -I../include(-I后面没空格,不加-I就在main.c中指定头文件的相对路径)
        gcc main.c   -o main -Wall     -I../include      -L../lib     -lsum(有库文件/lib/libsum.so就只要main.c就行)
        

        2个字节的-480在计算机中为0xfe20,ipmitool发指令:低位在前即0x20 0xfe。

        【c1】数据类型,运算符/循环,数组/指针,结构体,main参数,static/extern,typedef

        先确定字节数,再将最高位1固定。错误显示:100…010。正确存储:11…110。计算用正确存储。

        【c1】数据类型,运算符/循环,数组/指针,结构体,main参数,static/extern,typedef

        num=5 # 0000 0101
        result=$((~num))  # 得到: 1111 1010
        echo $result  # -6  # 负数在计算机中存储是取反加1,1000 0101 + 1 = 1000 0110(-6 错误显示)
        # 所以~作用是不管符号位,加1作用: 0000 0101 + 1 = 6
        num=-5 # 不是错误显示:1000 0101 ,是补码取反加1 :1111 1011
        result=$((~num))  # 得到: 0000 0100
        echo $result  # 4
        

        【c1】数据类型,运算符/循环,数组/指针,结构体,main参数,static/extern,typedef

        浮点数不是2的0次方+2的1次方…,最小可识别精度和浮点数即0.1本身大小相关,而不是和float相关。

        【c1】数据类型,运算符/循环,数组/指针,结构体,main参数,static/extern,typedef

        计算机中以字节为单位存储数据,1字节Byte=8bit,int=int32_t。

        【c1】数据类型,运算符/循环,数组/指针,结构体,main参数,static/extern,typedef

        【c1】数据类型,运算符/循环,数组/指针,结构体,main参数,static/extern,typedef

        d:十进制。o:八进制。x:十六进制。

        【c1】数据类型,运算符/循环,数组/指针,结构体,main参数,static/extern,typedef

        【c1】数据类型,运算符/循环,数组/指针,结构体,main参数,static/extern,typedef

        【c1】数据类型,运算符/循环,数组/指针,结构体,main参数,static/extern,typedef

        【c1】数据类型,运算符/循环,数组/指针,结构体,main参数,static/extern,typedef

        int main()
        {
            int value = 1;
            char str[10] = "-q1"; // NA:0 , -1:-1 , 1:1 , q1:0
            value = atoi(str);    //字符串转换为整数(不是ascii码), strtol
            printf("%d\n",value); //0
        }
        
        #define PLATFORM_NAME_PATH      "./a.py"
        void get_machine_ver(char * result)
        {
            char buffer[32] = {0};
            char cmd[128] = {0};
            strcpy(cmd, "python3 ");
            strcat(cmd, PLATFORM_NAME_PATH);
            FILE* file = popen(cmd, "r");
            if (file == NULL) {
                return;
            }
            // memset(buffer, '\0', sizeof(buffer));
            fgets(buffer, sizeof(buffer), file);
            printf("111,%ld\n",sizeof(buffer));  // 32   // char buffer[32] = {0};
            printf("222,%ld\n",strlen(buffer));  // 14 连换行符
            strncat(result, buffer, strlen(buffer)-1); // 去除换行符  // memcpy(result, buffer, strlen(buffer)-1); result长度不知,请确保 result 缓冲区足够大,以容纳 buffer 中的数据,并且不会发生缓冲区溢出的情况。
            // while (fgets(buffer, 10, file) != NULL) {
            //     strcat(result, buffer);
            // }
            pclose(file);
            return;
        }
        int main(){
            char result[32] = {0};
            get_machine_ver(result);
            printf("333,%s",result); // 333, HP1-2C4F-0..
        }
        

        1.数据输出:在C语言中,有三个函数可以把数据输出到屏幕。

        putchar 用于输出单个字符。

        puts 输出字符串。

        2.输出整数

        输出的整数常量或整数变量用%d表示,在参数中列出待输出的整数常量或整数变量。

        int age=18;

        printf(“我年龄是%d岁。\n”,age);

        3.输出字符

        输出的字符常量或字符变量用%c表示,在参数中列出待输出的字符常量或字符变量。

        char xb=‘x’;

        printf(“我姓别是:%c。\n”,xb);

        4.输出浮点数

        输出的浮点型常量或浮点型变量用%lf表示,在参数中列出待输出的浮点型常量或浮点型变量。

        double weight=62.5;

        printf(“我体重是%lf公斤。\n”, weight);

        5.输出字符串

        输出的字符串常量或字符串型变量用%s表示,在参数中列出待输出的字符串常量或字符串变量。

        char name[21];

        memset(name,0,sizeof(name));

        strcpy(name, “豫让”);

        printf(“我的姓名是%s。\n”,name);

        关键字:共32个,也就是说这些单词在C语言中有特别的含义,程序员不能把它用于变量或函数的命名。auto :声明自动变量。break:跳出当前循环。case:开关语句分支。char :声明字符型变量或函数返回值类型。const :声明只读变量。continue:结束当前循环,开始下一轮循环。default:开关语句中的“默认”分支。do :循环语句的循环体。double :声明双精度浮点型变量或函数返回值类型。else :条件语句否定分支(与 if 连用)。enum :声明枚举类型。extern:声明变量或函数是在其它文件或本文件的其他位置定义。float:声明浮点型变量或函数返回值类型。for:一种循环语句。goto:无条件跳转语句。if:条件语句。int: 声明整型变量或函数。long :声明长整型变量或函数返回值类型。register:声明寄存器变量。return :子程序返回语句(可以带参数,也可不带参数)。short :声明短整型变量或函数。signed:声明有符号类型变量或函数。sizeof:计算数据类型或变量长度(即所占字节数)。static:声明静态变量。struct:声明结构体类型。switch:用于开关语句。typedef:用以给数据类型取别名。unsigned:声明无符号类型变量或函数。union:声明共用体类型。void:声明函数无返回值或无参数,声明无类型指针。volatile:说明变量在程序执行中可被隐含地改变。while:循环语句的循环条件。

        2.运算符/循环:sizeof/size_t

        || 左边的命令返回假(命令返回值 $? == 1),|| 右边的命令才会被执行,和c语言逻辑或相同。

        【c1】数据类型,运算符/循环,数组/指针,结构体,main参数,static/extern,typedef

        如下ii++就是ii=ii+1。前先加1。

        【c1】数据类型,运算符/循环,数组/指针,结构体,main参数,static/extern,typedef

        =是赋值,==才是判断两个数是否相等,C语言没有(之间)的关系运算符,如年龄在25-30岁之间:年龄大于等于25岁并且年龄小于等于30岁。

        sizeof运算符(不是函数)计算某一个变量在当前系统的内存中所需占用的字节数:

        1.用于数据类型:sizeof(int)) = 4,sizeof(指针)大小永远是8字节。

        2.用于变量:sizeof使用形式:sizeof(var_name)或sizeof var_name。

        sizeof结果类型是size_t:typedef unsigned int size_t为无符号整型,长度为4个字节(32位系统)。typedef unsigned long size_t为无符号长整型,长度为8个字节(64位系统)。ssize_t是有符号整型(在32位机器上等同int,在64位机器上等同long int)。

        不要在if(判断条件)后面加分号。有;号就为空语句,下面都执行。c=(a>b)?a:b等同于两行:if(a>b) c=a;else c=b; if(0)即0假。if(a=b)是赋值,不是判断。当没有default时,如果所有case都匹配失败,则什么都不执行。char day=0,scanf(‘%c’',&day),case ‘0’。

        【c1】数据类型,运算符/循环,数组/指针,结构体,main参数,static/extern,typedef

        #include
        int main()
        {
          int a=1, b=2, re;
          char c;
          scanf("%c", &c);
          switch(c)
          {
            case '+':
              re = a + b;
              break;
            case '#':
            {
              int other = 3;   // switch语句里定义了新的变量 ,加{}
              re = a + b + other;
              break;
            }
            default:
              printf("Illegal input!\n");
              break;
          }
          printf("%d\n", re);
        }
        $gcc -o main *.c -lm
        $main
        Illegal input!
        0
        

        【c1】数据类型,运算符/循环,数组/指针,结构体,main参数,static/extern,typedef

        while(真)执行,continue跳到循环首部,break跳出循环。

        【c1】数据类型,运算符/循环,数组/指针,结构体,main参数,static/extern,typedef

        【c1】数据类型,运算符/循环,数组/指针,结构体,main参数,static/extern,typedef

        如下do-while先执行一次循环。

        【c1】数据类型,运算符/循环,数组/指针,结构体,main参数,static/extern,typedef

        for(i=0;i
            printf("%d\n",i); //没有下行0-9,有下行一直0
            i--;
        }
        
            FILE *fp=0;
            if ((fp=fopen("a","rt")) ==0)  //a文件里写了 333aaa
            {
                printf("111");
            }
            if (fgets(strbuf, 10, fp) == NULL) 
            {
                printf("222");
                fclose(fp);
            }
            strcpy(str,"B");
            strcat(str,strbuf);
            fclose(fp);
            return str;
        }
        int main()
        {
            char *b=a();
            printf("%s\n", b);  // B333aaa
        }
        int main()
        {
            FILE *fp=0;
            if ((fp = fopen("/tmp/bbb","r")) == 0)
            {
                printf("file do not exist\n");
                fclose(fp); // Segmentation fault (core dumped),fp不存在不能close,上行没打印出是因为fclose报错早于printf
                return -1;
            }
            fclose(fp); // 走不到
            return 0;
        }
        
            int len,i=0;
            char * pid_name_config_1[] = {"GPU111111110","CPU0_DIMM0","MOC2.5_CPU"};
            printf("000,%s\n",pid_name_config_1[0]);  // 000,GPU111111110
            printf("111,%ld\n",sizeof(pid_name_config_1[0])); // 111,8(指针大小)
            printf("222,%ld\n",sizeof(pid_name_config_1)); // 222,24(3*8)
            len = (sizeof(pid_name_config_1)/sizeof(pid_name_config_1[0]));
            printf("333,%d\n",len); // 333,3
            printf("444,%ld\n",sizeof("GPU0")); // 444,5(最后\0结束符)
            printf("555,%ld\n",strlen("GPU0")); // 555,4
            char pid_name[20]={0};  // char pid_name[20][20]={0}; 可以,每一行用来存字符串,不是字符
            for(i=0; i
                strcpy(pid_name[i], pid_name_config_1[i]); // 错误,strcpy参数expected ‘char * restrict’ but argument is of type ‘char
                memcpy(pid_name[i], pid_name_config_1[i], strlen(pid_name_config_1[i])); // 同上
                printf("666,%s\n", pid_name[i]);
            }
        }
        
        	  char *names = "PSU";
        	  if(strcmp(names,"PSU")==0)
        	  {
        		  puts("aaaa");  // 打印出
        	  }
        }
        int main() {   // error: expected ‘)’ before string constant    少了int main()
            char name_str[30];
            char name_str1[30];
            strcpy(name_str,"/sys/bus/i2c/devices/");
            strcpy(name_str1,"17-0064");
            strcat(name_str,name_str1);
            printf("is : %s\n", name_str);   // /sys/bus/i2c/devices/17-0064  
             // printf("[%s]__%4d__[%s]  %s \n", __FILE__, __LINE__, __FUNCTION__, n-name);
        }
        
           char str1[15];
           char str2[15];
           int ret;
           strcpy(str1, "abcdef");
           strcpy(str2, "ABCDEF");
           ret = strcmp(str1, str2);
           if(ret  
        
        #include 
        #include 
        #include
        #include 
        #include 
        #if 0
        int main() {
        	// int a;
        	 // char pNum[]="0x7f";
        	 // a=strtoul(pNum,0,16);
        	 // printf("%d\n",a);  //127 ,%x也是127 
        	 // return 0;
           char str[30] = "2030300 This is test";
           char *ptr;
           long ret;
           ret = strtoul(str, &ptr, 10);
           printf("数字(无符号长整数)是 %lu\n", ret);  // 2030300
           printf("字符串部分是 |%s|\n", ptr);  // This is test
           return 0;
        }
        #endif
        
        char temp_log_0[100] = {0};
        sprintf(temp_log_0, " '%d' ", a);
        char temp_log_1[100] = "echo ";
        strcat(temp_log_1, temp_log_0);
        char temp_log_2[100] = " >> /var/log/a.log";
        strcat(temp_log_1, temp_log_2);
        system(temp_log_1);  // C
        if(-1 == std::system(temp_log_1)){}; // CPP
        if(-1 == std::system("echo 'aaa' >> /var/log/a.log")){};
        
        #include 
        #include 
        #include 
         
        void cp (char *path_from, char *path_to)
        {
        	FILE *fp_read = NULL;
            FILE *fp_write = NULL;
            char ch = !EOF;
            fp_read = fopen(path_from, "r"); ///
            // if (fp_read == NULL)
            // {
            //     printf("您没有这个(%s)文件\n", path_from);
            // }
            fp_write = fopen(path_to, "w"); 
            
            while ((ch = fgetc(fp_read)) != EOF) // 读
            {
                fputc(ch,fp_write);   // 写
            }
            fclose(fp_read);
            fclose(fp_write);
        }
        int main(void)
        {
            char path_from[50];
            char path_to[50];
            printf("输入文件名:"); // D:\1.txt
            scanf("%s", path_from);
        	printf("\n输入文件名:"); // D:\2.txt,不存在会自动创建
            scanf("%s", path_to);
            cp(path_from,path_to); 
            return 0;
        }
        
        #include
        #include
        char* my_strcpy(char* dest, char* src)  //所以我这可以用两个char*类型了指针来接收
        {
        	assert(dest && src);//这个的意思就是避免dest和src是空指针,(如果有了这个assert(断言),就可以使当它们其中之一有空指针的时候就会报错,避免程序运行不报错,但要注意引头文件)
        	char* ret = dest;//写这步的好处和原因有两个 1.可以使我的dest发生改变的时候还有一个指针指向它,使我便与寻找 2.可以使我的返回类型变得更加完美,完美实现char*的返回值的目的
        	while (*src)
        	{
        		*dest = *src;//这个的意思就是把源头的字符赋值给目的地
        		dest++;//这两步一样就是使指针指向下一个字符,然后再循环
        		src++;
        	}
        	*dest = *src;//这步的目的就是因为上面那个循环的条件是 src!='\0',所以当src为'\0'时,循环就会停止,导致*dest = *src这步在最后不能实现,所以'\0'就没有拷贝到dest中,所以我最后还要再进行一步赋值
        	// while (*dest++ = *src++); // 这步的还是解引用后直接复制的意思,只是放在了循环之中(意思为当src为'\0'时,dest也为'\0',并且'\0'的ASCII码值为0,所以为假,所以此时循环依然停止), 这行可替代上面7行
        	return ret;
        }
        char* my_strncpy(char* dest, char* src, size_t num)  //比上面多了一个n
        {
        	assert(dest && src);//同理
        	char* ret = dest;
        	while (num)
        	{
        		*dest = *src;  //复制
        		src++;    //源地址往后+1
        		dest++;
        		num--; //我所需要拷贝的字符数随着我的循环一直减减
        	}
        	return ret;
        }
        int main()
        {
        	char arr1[] = "abcdef";
        	char arr2[20] = "bcd";
        	my_strcpy(arr2, arr1);//因为数组就是首元素的地址,所以这边传上去的其实就是两个地址
        	printf("%s",arr2);
        	return 0;
        }
        

        5.结构体:存放一组不同数据类型的数据

        【c1】数据类型,运算符/循环,数组/指针,结构体,main参数,static/extern,typedef

        如下最后一行*pst就是queen结构体变量。

        【c1】数据类型,运算符/循环,数组/指针,结构体,main参数,static/extern,typedef

        6.main函数的参数:main函数的参数是从命令提示符下执行程序时传入

        【c1】数据类型,运算符/循环,数组/指针,结构体,main参数,static/extern,typedef

        【c1】数据类型,运算符/循环,数组/指针,结构体,main参数,static/extern,typedef

        #include 
        int main(int argc, char **argv) {
          char *stty, *dev;
          dev = argv[1];
          stty = argv[2];
          printf("%s\n%s\n",dev,stty);
        }
        

        【c1】数据类型,运算符/循环,数组/指针,结构体,main参数,static/extern,typedef

        // a.c
        #include 
        #include 
        #include 
        #include 
        #include 
        #include 
        #include 
        #include 
        #include 
        extern int h_errno;
        int main(int argc, char **argv)
        {
        	char   *ptr, **pptr;
        	char    str[INET_ADDRSTRLEN];
        	struct hostent *hptr;  //
        	while (--argc> 0) 
        	{
        		ptr = *++argv;  //传入的域名
        		if ( (hptr = gethostbyname (ptr) ) == NULL)   //完成域名解析
        		{
        			printf("gethostbyname error for host: %s: %s",ptr, hstrerror (h_errno) );
        			continue;
        		}
        		printf ("official hostname: %s\n", hptr->h_name);
        		for (pptr=hptr->h_aliases; *pptr!= NULL; pptr++)
        			printf ("\talias: %s\n", *pptr);
        		switch (hptr->h_addrtype) 
        		{
        			case AF_INET:
        				pptr = hptr->h_addr_list;
        				for ( ; *pptr != NULL; pptr++)
        					printf ("\taddress: %s\n",inet_ntop (hptr->h_addrtype, *pptr, str, sizeof (str)));  //hptr->h_addrtype我们获取的IP地址
        				break;
        			
        			default:
        				printf("unknown address type");
        				break;
        		}
        	}
        	exit(0);
        }
        $ gcc a.c -o a
        $ ./a www.baidu.com
        official hostname: www.a.shifen.com
                alias: www.baidu.com
                address: 180.101.50.188  (浏览器输入都会跳转到百度)
                address: 180.101.50.242
        

        7.static/inline/回调/extern/堆内存:inline内联函数本身就是static(本文件私有)函数,inline函数在c中作用性不高,c中用习惯了宏定义

        什么函数被定义成内联函数呢?1.经常被调用(如果不经常被调用,节省一点时间也没意义),2.函数体里代码少(如果函数体里代码多,执行时间远大于跳转时间)。

        【c1】数据类型,运算符/循环,数组/指针,结构体,main参数,static/extern,typedef

        如下左边的你有一个私人厨师,你将50块钱和厨师电话作为参数传给老好人函数,老好人做了一些买菜挑菜等杂活后调用你的厨师进行做饭,老好人不仅为你服务还为其他人服务。

        【c1】数据类型,运算符/循环,数组/指针,结构体,main参数,static/extern,typedef

        如下方框是一个c文件,右边的c文件可以调到左边的var变量,每一个c文件不管里面写什么都可以编成o文件,右边的o文件var地址留空。最后链接成二进制文件时,链接就是编译,所以和1(外链)和2(内链)相关。

        【c1】数据类型,运算符/循环,数组/指针,结构体,main参数,static/extern,typedef

        extern表示引用外部的变量,从外面来的。

        【c1】数据类型,运算符/循环,数组/指针,结构体,main参数,static/extern,typedef

        8.typedef:define仅仅是简单的字符串的替换,而typedef则给这个类型新起了一个名字

        8.1 给已定义的变量类型起个别名:给struct __person起了个别名person_t

        struct __person
        {
            char    name[20];
            uint8_t age;
        }
        typedef __person person_t;
        //以上两段代码也可合并为一段:
        typedef struct __person
        {
        	...
        }person_t;
        

        8.2 定义函数指针类型:必须用typedef,方法就是在“定义函数指针变量”前加上typedef

        int (*pFunc)(char *frame, int len);  //定义了一个函数指针变量pFunc,它可以指向这样的函数:返回值为int,形参为char*、int
        int *(*pFunc[5])(int len);  //定义了5个函数指针变量:pFunc[0]、pFunc[1]···,它们都可以指向这样的函数:返回值为int*,形参为int
        //举例:
        typedef  int (*pFunc_t)(char *frame, int len); //定义了一个类型pFunc_t 
        int read_voltage(char *data, int len)
        {
            int voltage = 0;
            return voltage;
        }
        int main(void)
        {
            pFunc_t  pHandler = read_voltage;  //使用类型pFunc_t来定义函数指针变量
        }
        

        8.3 定义数组指针类型:先看如何定义数组指针变量

        int(*pArr)[5]; //定义了一个数组指针变量pArr,pArr可以指向一个int[5]的一维数组
        char(*pArr)[4][5]; //定义了一个数组指针变量pArr,pArr可以指向一个char[4][5]的二维数组
        //举例:
        int(*pArr)[5]; //pArr是一个指向含5个int元素(因为最前面是int)的一维数组的指针变量
        int a[5] = {1,2,3,4,5};
        int b[6] = {1,2,3,4,5,6};
        pArr = &a; //完全合法,无警告
        pArr = a; //发生编译警告,赋值时类型不匹配: a的类型为int(*) 相当于首地址,而pArr的类型为int(*)[5]
        pArr = &a[0]; //发生编译警告,赋值时类型不匹配: a的类型为int(*),而pArr的类型为int(*)[5]
        pArr = &b; //发生编译警告,赋值时类型不匹配:&b的类型为int(*)[6],而pArr的类型为int(*)[5]
        pArr = (int(*)[5])&b; //类型强制转换为int(*)[5],完全合法,无警告,但复杂,简化如下:
        typedef int(*pArr_t)[5];//定义一个指针类型,该类型的指针可以指向含5个int元素的一维数组
        int main(void)
        {
            int a[5] = {1,2,3,4,5};
            int b[6] = {1,2,3,4,5,6};
            pArr_t pA;//定义数组指针变量pA
            pA= &a;//完全合法,无警告    
            pA= (pArr_t)&b;//类型强制转换为pArr_t,完全合法,无警告
        }
        

        8.4 定义数组类型:声明一个含5个int元素的一维数组:int a[5]

        // 声明多个含5个int元素的一维数组:int a1[5], a2[5], a3[5]···,或者 a[N][5]   复杂,这时应该把数组定义为一个类型:
        typedef int arr_t[5];
        int main(void)
        {
            arr_t d;  //d是个数组,这一行等价于:  int d[5];
            arr_t b1, b2, b3; //b1, b2, b3都是数组
            d[0] = 1;
            d[5] = 253; //编译警告:下标越界
        }
        #define MaxNumbersOfName 10
        #define MaxNumbersOfPhones 20
        typedef char Elections_type[MaxNumbersOfNames]; // 10
        Elections_type Phone[MAXNambersOfPhones]={"HUAWEI","XIAOMI","SAMSUNG","APPLE"}; // char Phone[10][20]相同
        
        typedef struct _jmp_buf
        { 
            int _jb[_JBLEN + 1]; 
        } jmp_buf[1]; 
        // jmp_buf(定义变量实体的同时,也获得了该变量的地址)是一个含一个元素的数组类型,数组的元素为struct  _jmp_buf类型
        jmp_buf buf;      //这一行等价于:struct _jmp_buf buf[1]
        buf->_jb[5] = 34; //这一行等价于:(&buf[0])->_jb[5] = 34
        handle(buf);      //这一行等价于:handle(&buf[0])
        #define char* pchar;
        typedef pchar_type char*;
        // 只有p1,p2,p3被成功定义字符指针变量
        pchar_type p1,p2;
        pchar p3,p4;  // 在编译的时候就会被编译器看作char *p3,p4;造成了p4是一个char类型的变量
        
VPS购买请点击我

文章版权声明:除非注明,否则均为主机测评原创文章,转载或复制请以超链接形式并注明出处。

目录[+]