马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。
您需要 登录 才可以下载或查看，没有账号？立即注册
×
步伐布局
头文件包罗（#include）
- 功能与用途：头文件包罗指令是 C 语言中用于模块化和代码复用的告急机制。它答应我们将常用的函数声明、宏界说和范例界说等会合存放在一个文件中，然后在须要利用这些内容的源文件里通过 #include 指令将其引入。
- 标准库头文件：标准库头文件由 C 语言标准规定，包罗了浩繁实用的函数和范例声明。比方：
- stdio.h：提供了标准输入输出函数，像 printf、scanf、fopen 等。
- stdlib.h：包罗了动态内存分配函数（如 malloc、free）、随机数天生函数（如 rand）和步伐停止函数（如 exit）等。
- string.h：界说了一系列用于字符串处置惩罚的函数，比方 strcpy、strlen、strcmp 等。
- 自界说头文件：当我们在项目中编写了一些通用的函数或数据布局时，可以将其声明放在自界说头文件中。自界说头文件通常利用 .h 作为扩展名，利用双引号 “” 包罗。比方，创建一个名为 myheader.h 的头文件：
- // myheader.h
- #ifndef MYHEADER_H
- #define MYHEADER_H
- int add(int a, int b);
- #endif
- // main.c
- #include "myheader.h"
- #include <stdio.h>
- int add(int a, int b) {
- return a + b;
- }
- int main() {
- int result = add(3, 5);
- printf("Result: %d\n", result);
- return 0;
- }
- 头文件掩护：为了防止头文件被重复包罗，通常会利用预处置惩罚器指令 #ifndef、#define 和 #endif 来创建头文件掩护。如上述 myheader.h 中的示例，通过界说一个唯一的宏 MYHEADER_H，可以克制头文件被多次包罗导致的重复界说错误。
main() 函数
函数界说与返回值：main() 函数是 C 步伐的入口点，步伐从这里开始实行。它有两种常见的界讨情势：
- int main()：这种情势表现 main 函数不继承任何参数，返回一个整数值。返回值通常用于表现步伐的退出状态，0 表现步伐正常退出，非零值表现步伐非常退出。
- int main(int argc, char *argv[])：argc 表现下令行参数的数目，argv 是一个指向字符串数组的指针，存储了每个下令行参数。比方：
- #include <stdio.h>
- int main(int argc, char *argv[]) {
- if (argc > 1) {
- printf("You provided %d arguments:\n", argc - 1);
- for (int i = 1; i < argc; i++) {
- printf("%s\n", argv[i]);
- }
- } else {
- printf("No arguments provided.\n");
- }
- return 0;
- }
解释（// 和 /* */）
单行解释（//）：用于对代码的某一行或某一部门举行简短的阐明。单行解释从 // 开始，到该行竣事为止。比方：
- // 这是一个简单的加法函数
- int add(int a, int b) {
- return a + b; // 返回两数之和
- }
- /*
- * 这是一个更复杂的函数
- * 它接受两个整数作为参数
- * 并返回它们的乘积
- */
- int multiply(int a, int b) {
- return a * b;
- }
界说与初始化
变量界说：在 C 语言中，变量必须先界说后利用。变量界说的一样平常情势为：数据范例 变量名;。比方：
- int num; // 定义一个整型变量 num
- char ch; // 定义一个字符型变量 ch
- float f; // 定义一个单精度浮点型变量 f
- double d; // 定义一个双精度浮点型变量 d
- int age = 25; // 直接赋值初始化
- float radius = 3.14f * 2; // 表达式赋值初始化
作用域（全局变量、局部变量）
全局变量：全局变量界说在函数外部，具有全局作用域，即可以在步伐的任何函数中访问。全局变量在步伐启动时被创建，在步伐竣事时被烧毁。比方：
- #include <stdio.h>
- // 全局变量
- int global_var = 10;
- void func() {
- printf("Global variable in func: %d\n", global_var);
- }
- int main() {
- printf("Global variable in main: %d\n", global_var);
- func();
- return 0;
- }
- #include <stdio.h>
- void func() {
- // 局部变量
- int local_var = 20;
- printf("Local variable in func: %d\n", local_var);
- }
- int main() {
- func();
- // 下面这行代码会导致编译错误，因为 local_var 是 func 函数的局部变量
- // printf("Local variable in main: %d\n", local_var);
- return 0;
- }
常量
- 字面常量：字面常量是直接出如今代码中的常量值，如整数常量（10、-20）、浮点常量（3.14、2.718）、字符常量（‘A’、‘b’）和字符串常量（“Hello, World!”）等。
- const 修饰的常量：利用 const 关键字可以界说常量，一旦界说，其值不能被修改。比方：
- #include <stdio.h>
- int main() {
- const int MAX_VALUE = 100;
- // 下面这行代码会导致编译错误，因为 MAX_VALUE 是常量，不能被修改
- // MAX_VALUE = 200;
- printf("Max value: %d\n", MAX_VALUE);
- return 0;
- }
- 宏界说常量：利用 #define 预处置惩罚器指令可以界说宏常量。宏常量在预处置惩罚阶段会被直接更换为其对应的值。比方：
- #include <stdio.h>
- #define PI 3.14159
- int main() {
- float radius = 5.0;
- float area = PI * radius * radius;
- printf("Area of circle: %f\n", area);
- return 0;
- }
根本数据范例
int 范例：int 范例用于表现整数，其巨细通常取决于编译器和利用体系。在大多数 32 位体系中，int 范例占用 4 个字节，取值范围为 -2147483648 到 2147483647。可以利用差别的修饰符来改变 int 范例的范围，如 short int（通常占用 2 个字节）、long int（通常占用 4 或 8 个字节）和 long long int（通常占用 8 个字节）。比方：
- #include <stdio.h>
- int main() {
- int num = 100;
- short int short_num = 32767;
- long int long_num = 2147483647L;
- long long int long_long_num = 9223372036854775807LL;
- printf("int: %d\n", num);
- printf("short int: %d\n", short_num);
- printf("long int: %ld\n", long_num);
- printf("long long int: %lld\n", long_long_num);
- return 0;
- }
- #include <stdio.h>
- int main() {
- char ch = 'A';
- printf("Character: %c\n", ch);
- printf("ASCII value: %d\n", ch);
- return 0;
- }
- #include <stdio.h>
- int main() {
- float f = 3.14f;
- double d = 3.1415926535;
- printf("Float: %f\n", f);
- printf("Double: %lf\n", d);
- return 0;
- }
隐式范例转换：隐式范例转换是编译器主动举行的范例转换，通常发生在差别范例的数据举行运算时。隐式范例转换的规则是将低精度范例转换为高精度范例，以克制数据丢失。比方：
- #include <stdio.h>
- int main() {
- int a = 10;
- float b = 3.14f;
- float result = a + b; // 整数 a 会被隐式转换为浮点数
- printf("Result: %f\n", result);
- return 0;
- }
- #include <stdio.h>
- int main() {
- float f = 3.14f;
- int i = (int)f; // 显式将浮点数 f 转换为整数，小数部分会被截断
- printf("Integer: %d\n", i);
- return 0;
- }
算术运算符
根本算术运算符
包罗加（+）、减（-）、乘（*）、除（/）和取模（%）。须要注意的是，整数除法会截断小数部门，取模运算符只能用于整数范例。比方：
- #include <stdio.h>
- int main() {
- int a = 10;
- int b = 3;
- int sum = a + b;
- int diff = a - b;
- int prod = a * b;
- int quot = a / b; // 结果为 3，小数部分被截断
- int rem = a % b;
- printf("Sum: %d\n", sum);
- printf("Difference: %d\n", diff);
- printf("Product: %d\n", prod);
- printf("Quotient: %d\n", quot);
- printf("Remainder: %d\n", rem);
- return 0;
- }
自增运算符（++）和自减运算符（–）用于将变量的值加 1 或减 1。它们有前置和后置两种情势，前置情势先辈行自增或自减利用，再返回变量的值；后置情势先返回变量的值，再举行自增或自减利用。比方：
- #include <stdio.h>
- int main() {
- int a = 10;
- int b = ++a; // 前置自增，a 先加 1 变为 11，然后将 11 赋值给 b
- int c = a--; // 后置自减，先将 a 的值 11 赋值给 c，然后 a 减 1 变为 10
- printf("a: %d\n", a);
- printf("b: %d\n", b);
- printf("c: %d\n", c);
- return 0;
- }
逻辑与（&&）
逻辑与运算符用于判断两个条件是否同时为真。只有当两个利用数都为真时，效果才为真；否则，效果为假。比方：
- #include <stdio.h>
- int main() {
- int a = 1;
- int b = 0;
- int result = a && b;
- printf("Logical AND: %d\n", result);
- return 0;
- }
逻辑或运算符用于判断两个条件是否至少有一个为真。只要有一个利用数为真，效果就为真；只有当两个利用数都为假时，效果才为假。比方：
- #include <stdio.h>
- int main() {
- int a = 1;
- int b = 0;
- int result = a || b;
- printf("Logical OR: %d\n", result);
- return 0;
- }
逻辑非运算符用于取反一个条件的值。如果利用数为真，效果为假；如果利用数为假，效果为真。比方：
- #include <stdio.h>
- int main() {
- int a = 1;
- int result = !a;
- printf("Logical NOT: %d\n", result);
- return 0;
- }
按位与（&）
按位与运算符对两个利用数的对应二进制位举行与运算。只有当两个对应位都为 1 时，效果位才为 1；否则，效果位为 0。比方：
- #include <stdio.h>
- int main() {
- int a = 5; // 二进制: 0101
- int b = 3; // 二进制: 0011
- int result = a & b; // 二进制: 0001
- printf("Bitwise AND: %d\n", result);
- return 0;
- }
按位或运算符对两个利用数的对应二进制位举行或运算。只要有一个对应位为 1，效果位就为 1；只有当两个对应位都为 0 时，效果位才为 0。比方：
- #include <stdio.h>
- int main() {
- int a = 5; // 二进制: 0101
- int b = 3; // 二进制: 0011
- int result = a | b; // 二进制: 0111
- printf("Bitwise OR: %d\n", result);
- return 0;
- }
按位异或运算符对两个利用数的对应二进制位举行异或运算。当两个对应位差别时，效果位为 1；当两个对应位雷同时，效果位为 0。比方：
- #include <stdio.h>
- int main() {
- int a = 5; // 二进制: 0101
- int b = 3; // 二进制: 0011
- int result = a ^ b; // 二进制: 0110，结果为 6
- printf("Bitwise XOR: %d\n", result);
- // 利用异或交换两个变量的值
- a = a ^ b;
- b = a ^ b;
- a = a ^ b;
- printf("After swap: a = %d, b = %d\n", a, b);
- return 0;
- }
按位取反运算符对利用数的每一个二进制位举行取反利用，即 0 变为 1，1 变为 0。示比方下：
- #include <stdio.h>
- int main() {
- int num = 5; // 二进制: 0000 0000 0000 0000 0000 0000 0000 0101
- int result = ~num; // 二进制: 1111 1111 1111 1111 1111 1111 1111 1010
- printf("Bitwise NOT: %d\n", result);
- return 0;
- }
左移（<<）
左移运算符将利用数的二进制位向左移动指定的位数，右边空出的位用 0 添补。左移一位相称于将原数乘以 2。示例代码如下：
- #include <stdio.h>
- int main() {
- int num = 5; // 二进制: 0000 0000 0000 0000 0000 0000 0000 0101
- int result = num << 2; // 二进制: 0000 0000 0000 0000 0000 0000 0001 0100，结果为 20
- printf("Left shift: %d\n", result);
- return 0;
- }
右移（>>）
右移运算符将利用数的二进制位向右移动指定的位数。对于无符号整数，左边空出的位用 0 添补；对于有符号整数，左边空出的位根据符号位添补（正数补 0，负数补 1，这称为算术右移）。右移一位相称于将原数除以 2（向下取整）。示比方下：
- #include <stdio.h>
- int main() {
- int num = 20; // 二进制: 0000 0000 0000 0000 0000 0000 0001 0100
- int result = num >> 2; // 二进制: 0000 0000 0000 0000 0000 0000 0000 0101，结果为 5
- printf("Right shift: %d\n", result);
- int negative_num = -20; // 假设为补码表示
- int negative_result = negative_num >> 2;
- printf("Right shift of negative number: %d\n", negative_result);
- return 0;
- }
简单赋值（=）
简单赋值运算符用于将右边表达式的值赋给左边的变量。比方：
- #include <stdio.h>
- int main() {
- int a = 10;
- int b;
- b = a; // 将 a 的值赋给 b
- printf("b: %d\n", b);
- return 0;
- }
复合赋值运算符（+=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=）是将算术运算或位运算与赋值利用团结起来的简写情势。比方：
- #include <stdio.h>
- int main() {
- int a = 10;
- a += 5; // 等价于 a = a + 5
- printf("a after +=: %d\n", a);
- int b = 8;
- b &= 3; // 等价于 b = b & 3
- printf("b after &=: %d\n", b);
- return 0;
- }
在一个表达式中，如果包罗多个运算符，运算符的优先级和团结性决定了运算的先后序次。比方，乘法和除法的优先级高于加法和减法，括号可以改变运算的优先级。团结性则决定了雷同优先级运算符的盘算序次，大多数算术运算符是左团结的。以下是一个示例：
- #include <stdio.h>
- int main() {
- int result = 2 + 3 * 4; // 先计算 3 * 4，再加上 2
- printf("Result: %d\n", result);
- result = (2 + 3) * 4; // 先计算括号内的 2 + 3，再乘以 4
- printf("Result with parentheses: %d\n", result);
- return 0;
- }
|
发表于 2025-10-22 00:37:21