数据类型
#include// struct datatype struct person { char name[50]; int age; float salary; }; // enum datatype enum color {red, green, blue}; int main() { // basic data types int a = 10; // 4 bytes float b = 5.5; //4 bytes char c = 'a'; //1 byte double d = 2.3; //8 bytes long double e; // 16 bytes (64-bit), 12 bytes (32-bit) short integer f; // 2 bytes long int g; //8 bytes (64-bit), 4 bytes (32-bit) // array int arr[5] = {1, 2, 3, 4, 5}; // pointer int *ptr = &a; // structure struct person person1; person1.age = 30; person1.salary = 55000.50; // enumeration enum color mycolor = red; // print values printf("integer: %d\n", a); printf("float: %.2f\n", b); printf("character: %c\n", c); printf("array: %d\n", arr[0]); printf("pointer: %d\n", *ptr); printf("structure: name = %s", person1.name); printf("enumeration: %d\n", mycolor); return 0; }
真实数据类型：
浮动、双倍和长双倍
记忆片段
文本段（代码段）
它包含编译后的机器代码数据段
存储由程序员初始化的全局变量和静态变量。
两种类型：
初始化数据段：包含在程序中显式初始化的全局变量和静态变量。
前任。 int x=2;
未初始化数据段（bss）：包含未显式初始化的全局变量和静态变量。
前任。 int x;
堆
它用于运行时动态内存分配。堆叠
它存储局部变量、函数参数和返回地址。
函数原型
是函数的声明，指定函数的名称、返回类型和参数，但不提供函数体。
（注意： 放在源文件的开头，可以有多个，但只能定义一个）
#include// function prototype with formal parameters void func(char name[]); int main() { char name[] = "alice"; //actual parameters greet(name); return 0; } // function definition void func(char name[]) { printf("hello, %s!\n", name); }
mod/模数
此运算符仅用于整数数据类型。在 float 数据类型上使用模数是非法的
#include#include int main() { double dividend = 7.5; double divisor = 2.0; double result; int i=2; i=i%10;//works on integer types result = fmod(dividend, divisor); printf("%.1f",result); //for float types return 0; }
for循环
#includeint main() { int x; for(x=1; x<=10; x++) { // ternary conditional operator a <= 20 ? (b = 30) : (c = 30); } return 0; }
while 循环
#includeint main() { int j=1; while(j <= 255) { j++; } return 0; }
宏观
它是一段被赋予名称的代码片段，可用于在实际编译之前的预处理阶段在代码中执行文本替换。
#define pi 3.14159 #define square(x) ((x) * (x))
开关盒
#includeint main() { int day = 3; switch (day) { case 1: printf("monday\n"); break; case 2: printf("tuesday\n"); break; default: printf("invalid day\n"); break; } return 0; }
内存管理
malloc：分配内存但不初始化它。内存中包含垃圾值。
calloc：分配内存并将所有位初始化为零。
#include#include int main() { int *array; int size = 5; // allocate memory for an array of integers array = (int *)malloc(size * sizeof(int)); // deallocate the memory free(array); int *a[3]; a = (int*) malloc(sizeof(int)*3); free(a); return 0; }
指针
它提供了一种直接访问和操作内存的方法。
指针是一个变量，它存储另一个变量的内存地址。指针不是直接保存数据值，而是保存数据在内存中的位置。
基本指针操作
声明：
int *ptr; // declares a pointer to an integer
初始化：
int x = 10; int *ptr = &x; // `ptr` now holds the address of `x`
取消引用：
访问存储在指定地址的值
int value = *ptr; // retrieves the value of `x` via `ptr`
样品
#includeint main() { int a = 5; // normal integer variable int *p = &a; // pointer `p` points to `a` printf("value of a: %d\n", a); // output: 5 printf("address of a: %p\n", (void*)&a); // output: address of `a` printf("value of p: %p\n", (void*)p); // output: address of `a` printf("value pointed to by p: %d\n", *p); // output: 5 *p = 10; // modifies `a` through the pointer printf("new value of a: %d\n", a); // output: 10 return 0; }
指向指针的指针
int x = 10; int *ptr = &x; int **pptr = &ptr; // pointer to pointer
指向结构体的指针
#include#include #include // define a structure struct person { char name[50]; int age; }; int main() { // declare a pointer to a structure struct person *ptr; // allocate memory for the structure ptr = (struct person *)malloc(sizeof(struct person)); if (ptr == null) { printf("memory allocation failed\n"); return 1; } // use the arrow operator to access and set structure members strcpy(ptr->name, "alice"); ptr->age = 30; // print structure members printf("name: %s\n", ptr->name); printf("age: %d\n", ptr->age); // free allocated memory free(ptr); return 0; }
关键词
外部的
用于声明在另一个文件中或稍后在同一文件中定义的全局变量或函数。
#includeint main() { extern int a; // accesses a variable from outside printf("%d\n", a); return 0; } int a = 20;
静止的
全局静态变量：
全局静态变量是在任何函数外部使用 static 关键字声明的。
范围仅限于声明它的文件。这意味着它无法从其他文件访问。如果没有显式初始化，全局静态变量会自动初始化为零。
#includestatic int global_var = 10; // global static variable void display(void) { printf("global variable: %d\n", global_var); // accesses global static variable } int main(void) { display(); // prints 10 global_var = 20; display(); // prints 20 return 0; }
局部静态变量
局部静态变量在函数内部使用 static 关键字声明。
范围仅限于声明它的函数。不能从函数外部访问它。如果没有显式初始化，局部静态变量会自动初始化为零。
#includevoid counter(void) { static int count = 0; // local static variable count++; printf("count: %d\n", count); // prints the current value of count } int main(void) { counter(); // prints 1 counter(); // prints 2 counter(); // prints 3 return 0; }
注意： 在 c 中，当你有一个同名的全局变量和局部变量时，局部变量会在其作用域内隐藏（或隐藏）全局变量。
结构体
struct book
{
char name[10];
float price;
int pages;
};
类型定义
它用于为现有类型创建别名
typedef unsigned int uint;
int main() {
uint x = 10; // equivalent to unsigned int x = 10;
printf("x = %u\n", x);
return 0;
}
typedef struct Ntype {
int i;
char c;
long x;
} NewType;
连锁
指符号（变量和函数）跨源文件的可见性
外部链接：该符号在多个翻译单元中可见（全局）
内部链接：符号仅在定义它的翻译单元内可见
无（无链接）：符号在定义它的块之外不可见（局部变量）
