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

05-13 1112阅读

文章目录

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中看不到。

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。

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

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

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

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

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

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语言逻辑或相同。

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

=是赋值，==才是判断两个数是否相等，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’。

#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

while（真）执行，continue跳到循环首部，break跳出循环。

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

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.结构体：存放一组不同数据类型的数据 
如下最后一行*pst就是queen结构体变量。
 
6.main函数的参数：main函数的参数是从命令提示符下执行程序时传入 
 
#include 
int main(int argc, char **argv) {
  char *stty, *dev;
  dev = argv[1];
  stty = argv[2];
  printf("%s\n%s\n",dev,stty);
}
 
 
// 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.函数体里代码少（如果函数体里代码多，执行时间远大于跳转时间）。
如下左边的你有一个私人厨师，你将50块钱和厨师电话作为参数传给老好人函数，老好人做了一些买菜挑菜等杂活后调用你的厨师进行做饭，老好人不仅为你服务还为其他人服务。
如下方框是一个c文件，右边的c文件可以调到左边的var变量，每一个c文件不管里面写什么都可以编成o文件，右边的o文件var地址留空。最后链接成二进制文件时，链接就是编译，所以和1（外链）和2（内链）相关。
extern表示引用外部的变量，从外面来的。
 
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类型的变量