我的个人博客

C语言基础语法

返回首页
技术分享 2025-12-20

C语言基础语法

🏗️ 基本框架

每个C程序都必须包含一个main()函数作为程序入口点：

#include <stdio.h>  // 标准输入输出库

int main() {
    // 程序代码
    printf("Hello, World!\n");
    return 0;  // 返回0表示程序正常结束
}

📊 数据类型

基本数据类型

类型 说明 占用字节 格式化符号
int 整型 4 %d
float 单精度浮点型 4 %f
double 双精度浮点型 8 %lf
char 字符型 1 %c
bool 布尔型(C99) 1 %d

类型使用示例

#include <stdio.h>
#include <stdbool.h>  // 使用bool类型需要包含此头文件

int main() {
    int age = 25;
    float height = 175.5f;  // f后缀表示float类型
    double weight = 68.5;   // 默认为double类型
    char grade = 'A';
    bool is_student = true;
    
    printf("年龄: %d岁\n", age);
    printf("身高: %.1fcm\n", height);
    printf("体重: %.1lfkg\n", weight);
    printf("等级: %c\n", grade);
    printf("是学生: %s\n", is_student ? "是" : "否");
    
    return 0;
}

四大常用类型

int，bool

float不加字面量f就会自动转换为double

char整数输出char型会得到字符的ascii码

int a=10;float b=3.14f;char c="a";
printf("整形:%d,浮点型%f,字符型:%c",a,b,c);

🔧 运算符

算术运算符

+   // 加法
-   // 减法
*   // 乘法
/   // 除法
%   // 取模(求余)

关系运算符

>   // 大于
<   // 小于
==  // 等于
<=  // 小于等于
>=  // 大于等于
!=  // 不等于

逻辑运算符

&&  // 逻辑与(AND)
||  // 逻辑或(OR)
!   // 逻辑非(NOT)

位运算符

&   // 按位与
|   // 按位或
~   // 按位取反
<<  // 左移
>>  // 右移
^   // 按位异或

赋值运算符

=   // 赋值
+=  // 加后赋值
-=  // 减后赋值
*=  // 乘后赋值
/=  // 除后赋值
%=  // 取模后赋值

其他运算符

条件表达式 ? 值1 : 值2  // 三元运算符
sizeof(类型)           // 计算类型或变量大小
&变量名                // 取地址运算符
*指针变量              // 间接寻址运算符

🎮 控制语句

条件语句 - if-else

if (条件表达式) {
    // 条件为真时执行
    printf("条件成立\n");
} else {
    // 条件为假时执行
    printf("条件不成立\n");
}

// 多重if-else
if (score >= 90) {
    printf("优秀\n");
} else if (score >= 80) {
    printf("良好\n");
} else if (score >= 60) {
    printf("及格\n");
} else {
    printf("不及格\n");
}

循环语句 - for

// 基本语法
for (初始化; 条件; 更新) {
    // 循环体
}

// 示例：打印1-10
for (int i = 1; i <= 10; i++) {
    printf("%d ", i);
}

// 嵌套循环：乘法表
for (int i = 1; i <= 9; i++) {
    for (int j = 1; j <= i; j++) {
        printf("%d×%d=%d\t", j, i, i*j);
    }
    printf("\n");
}

循环语句 - while

// 先判断条件，再执行循环体
int i = 1;
while (i <= 10) {
    printf("%d ", i);
    i++;  // 重要：更新循环变量
}

循环语句 - do-while

// 先执行一次循环体，再判断条件
int i;
do {
    printf("请输入一个正数: ");
    scanf("%d", &i);
} while (i <= 0);

分支语句 - switch

switch (表达式) {
    case 常量1:
        // 执行代码块1
        break;
    case 常量2:
        // 执行代码块2
        break;
    // 可以有多个case
    default:
        // 所有case都不匹配时执行
        printf("无效选项\n");
        break;
}

// 示例：成绩等级转换
char grade = 'B';
switch (grade) {
    case 'A':
        printf("优秀(90-100)\n");
        break;
    case 'B':
        printf("良好(80-89)\n");
        break;
    case 'C':
        printf("中等(70-79)\n");
        break;
    case 'D':
        printf("及格(60-69)\n");
        break;
    default:
        printf("不及格(<60)\n");
}

📚 数组

一维数组

// 声明和初始化
int scores[5];                    // 声明包含5个整数的数组
int numbers[5] = {1, 2, 3, 4, 5}; // 声明并初始化
int arr[] = {10, 20, 30, 40};     // 自动计算数组长度

// 数组操作
int grades[100];
int sum = 0;
int count = 5;

// 输入数组元素
for (int i = 0; i < count; i++) {
    printf("请输入第%d个成绩: ", i + 1);
    scanf("%d", &grades[i]);
}

// 计算平均值
for (int i = 0; i < count; i++) {
    sum += grades[i];
}
float average = (float)sum / count;

// 查找最大值
int max = grades[0];
for (int i = 1; i < count; i++) {
    if (grades[i] > max) {
        max = grades[i];
    }
}

二维数组

// 声明和初始化
int matrix[3][4];                          // 3行4列的矩阵
int table[2][3] = {{1, 2, 3}, {4, 5, 6}}; // 声明并初始化

// 矩阵操作示例
int rows = 3, cols = 4;
int matrix[3][4];

// 输入矩阵
for (int i = 0; i < rows; i++) {
    for (int j = 0; j < cols; j++) {
        printf("请输入matrix[%d][%d]: ", i, j);
        scanf("%d", &matrix[i][j]);
    }
}

// 打印矩阵
printf("矩阵内容:\n");
for (int i = 0; i < rows; i++) {
    for (int j = 0; j < cols; j++) {
        printf("%3d ", matrix[i][j]);
    }
    printf("\n");
}

// 计算每行和
for (int i = 0; i < rows; i++) {
    int row_sum = 0;
    for (int j = 0; j < cols; j++) {
        row_sum += matrix[i][j];
    }
    printf("第%d行的和: %d\n", i + 1, row_sum);
}

字符数组

// 字符串的表示
char str1[20] = "Hello";           // 字符数组形式
char str2[] = "World";             // 自动计算长度
char str3[20] = {'H', 'e', 'l', 'l', 'o', '\0'}; // 手动添加结束符

// 字符串输入输出
char name[50];
printf("请输入你的名字: ");
scanf("%s", name);  // 注意：scanf遇到空格会停止
printf("你好, %s!\n", name);

// 使用fgets读取整行
char sentence[100];
printf("请输入一句话: ");
fgets(sentence, sizeof(sentence), stdin);  // 可以读取包含空格的字符串
sentence[strcspn(sentence, "\n")] = '\0';  // 移除换行符
printf("你说: %s\n", sentence);

🔤 字符串

字符串基本操作

#include <stdio.h>
#include <string.h>  // 字符串操作函数库

int main() {
    char str1[100] = "Hello";
    char str2[] = "World";
    char result[200];
    
    // 字符串连接
    strcpy(result, str1);     // 复制str1到result
    strcat(result, " ");      // 在result后追加空格
    strcat(result, str2);     // 在result后追加str2
    printf("连接结果: %s\n", result);  // Hello World
    
    // 字符串长度
    int len = strlen(result);
    printf("字符串长度: %d\n", len);
    
    // 字符串比较
    char str3[] = "Hello";
    if (strcmp(str1, str3) == 0) {
        printf("str1和str3相同\n");
    }
    
    // 字符串查找
    char *pos = strchr(result, 'W');  // 查找字符'W'
    if (pos != NULL) {
        printf("找到字符'W'的位置: %ld\n", pos - result);
    }
    
    return 0;
}

常用字符串函数

#include <stdio.h>
#include <string.h>
#include <ctype.h>  // 字符处理函数

// 自定义字符串反转函数
void reverse_string(char *str) {
    int len = strlen(str);
    for (int i = 0; i < len / 2; i++) {
        char temp = str[i];
        str[i] = str[len - 1 - i];
        str[len - 1 - i] = temp;
    }
}

// 自定义字符串转大写函数
void to_uppercase(char *str) {
    for (int i = 0; str[i] != '\0'; i++) {
        str[i] = toupper(str[i]);
    }
}

int main() {
    char text[100] = "Hello C Programming";
    
    printf("原字符串: %s\n", text);
    
    // 反转字符串
    reverse_string(text);
    printf("反转后: %s\n", text);
    
    // 再次反转恢复原状
    reverse_string(text);
    
    // 转换为大写
    to_uppercase(text);
    printf("大写形式: %s\n", text);
    
    // 字符串分割示例
    char sentence[] = "C,Java,Python,JavaScript";
    char *token = strtok(sentence, ",");
    printf("分割结果:\n");
    while (token != NULL) {
        printf("- %s\n", token);
        token = strtok(NULL, ",");
    }
    
    return 0;
}

⚙️ 函数

函数定义和调用

#include <stdio.h>

// 函数声明(原型)
int add(int a, int b);
double calculate_average(int scores[], int count);
void print_greeting(char name[]);
int max_of_three(int a, int b, int c);

// 主函数
int main() {
    // 调用加法函数
    int result = add(10, 20);
    printf("10 + 20 = %d\n", result);
    
    // 调用平均值计算函数
    int scores[] = {85, 92, 78, 96, 88};
    double avg = calculate_average(scores, 5);
    printf("平均分: %.2f\n", avg);
    
    // 调用问候函数
    print_greeting("张三");
    
    // 调用最大值函数
    int max_val = max_of_three(15, 27, 12);
    printf("三个数中的最大值: %d\n", max_val);
    
    return 0;
}

// 函数定义：两数相加
int add(int a, int b) {
    return a + b;
}

// 函数定义：计算数组平均值
double calculate_average(int scores[], int count) {
    int sum = 0;
    for (int i = 0; i < count; i++) {
        sum += scores[i];
    }
    return (double)sum / count;
}

// 函数定义：打印问候语
void print_greeting(char name[]) {
    printf("你好, %s! 欢迎学习C语言。\n", name);
}

// 函数定义：求三个数的最大值
int max_of_three(int a, int b, int c) {
    int max = a;
    if (b > max) max = b;
    if (c > max) max = c;
    return max;
}

递归函数

#include <stdio.h>

// 递归计算阶乘
long factorial(int n) {
    if (n <= 1) {
        return 1;
    }
    return n * factorial(n - 1);
}

// 递归计算斐波那契数列
int fibonacci(int n) {
    if (n <= 1) {
        return n;
    }
    return fibonacci(n - 1) + fibonacci(n - 2);
}

// 递归实现汉诺塔
void hanoi(int n, char from, char to, char aux) {
    if (n == 1) {
        printf("将盘子1从%c移动到%c\n", from, to);
        return;
    }
    hanoi(n - 1, from, aux, to);
    printf("将盘子%d从%c移动到%c\n", n, from, to);
    hanoi(n - 1, aux, to, from);
}

int main() {
    // 阶乘示例
    int num = 5;
    printf("%d! = %ld\n", num, factorial(num));
    
    // 斐波那契数列示例
    printf("斐波那契数列前10项:\n");
    for (int i = 0; i < 10; i++) {
        printf("%d ", fibonacci(i));
    }
    printf("\n");
    
    // 汉诺塔示例
    printf("3个盘子的汉诺塔移动步骤:\n");
    hanoi(3, 'A', 'C', 'B');
    
    return 0;
}

📍 指针

指针基础

#include <stdio.h>

int main() {
    int num = 42;
    int *ptr;        // 声明指针变量
    ptr = #      // 指针指向num的地址
    
    printf("变量num的值: %d\n", num);
    printf("变量num的地址: %p\n", &num);
    printf("指针ptr存储的地址: %p\n", ptr);
    printf("通过指针访问的值: %d\n", *ptr);
    printf("指针ptr本身的地址: %p\n", &ptr);
    
    // 通过指针修改变量值
    *ptr = 100;
    printf("修改后num的值: %d\n", num);
    
    return 0;
}

指针和数组

#include <stdio.h>

int main() {
    int arr[5] = {10, 20, 30, 40, 50};
    int *ptr = arr;  // 数组名就是数组首元素的地址
    
    // 使用指针遍历数组
    printf("使用指针遍历数组:\n");
    for (int i = 0; i < 5; i++) {
        printf("arr[%d] = %d\n", i, *(ptr + i));
        printf("地址: %p\n", ptr + i);
    }
    
    // 指针算术
    ptr = arr;
    printf("\n指针算术演示:\n");
    printf("ptr指向: %d\n", *ptr);
    ptr++;  // 指针向后移动一个int的位置
    printf("ptr++后指向: %d\n", *ptr);
    ptr += 2;  // 指针向后移动两个int的位置
    printf("ptr+=2后指向: %d\n", *ptr);
    
    return 0;
}

指针和函数

#include <stdio.h>

// 使用指针参数交换两个数的值
void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

// 使用指针修改数组元素
void double_values(int *arr, int size) {
    for (int i = 0; i < size; i++) {
        arr[i] *= 2;  // 等价于 *(arr + i) *= 2
    }
}

// 函数返回指针
int* find_max(int *arr, int size) {
    if (size <= 0) return NULL;
    
    int *max_ptr = arr;
    for (int i = 1; i < size; i++) {
        if (arr[i] > *max_ptr) {
            max_ptr = &arr[i];
        }
    }
    return max_ptr;
}

int main() {
    // 交换示例
    int x = 10, y = 20;
    printf("交换前: x = %d, y = %d\n", x, y);
    swap(&x, &y);
    printf("交换后: x = %d, y = %d\n", x, y);
    
    // 数组修改示例
    int numbers[] = {1, 2, 3, 4, 5};
    int size = sizeof(numbers) / sizeof(numbers[0]);
    
    printf("\n修改前的数组: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", numbers[i]);
    }
    
    double_values(numbers, size);
    
    printf("\n修改后的数组: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", numbers[i]);
    }
    
    // 查找最大值
    int *max_ptr = find_max(numbers, size);
    if (max_ptr != NULL) {
        printf("\n最大值: %d, 地址: %p\n", *max_ptr, max_ptr);
    }
    
    return 0;
}

动态内存分配

#include <stdio.h>
#include <stdlib.h>  // 内存分配函数库

int main() {
    // 动态分配单个整数
    int *dynamic_num = (int*)malloc(sizeof(int));
    if (dynamic_num == NULL) {
        printf("内存分配失败\n");
        return 1;
    }
    
    *dynamic_num = 100;
    printf("动态分配的整数: %d\n", *dynamic_num);
    free(dynamic_num);  // 释放内存
    
    // 动态分配数组
    int n;
    printf("请输入数组大小: ");
    scanf("%d", &n);
    
    int *dynamic_array = (int*)malloc(n * sizeof(int));
    if (dynamic_array == NULL) {
        printf("内存分配失败\n");
        return 1;
    }
    
    // 输入数组元素
    for (int i = 0; i < n; i++) {
        printf("请输入第%d个元素: ", i + 1);
        scanf("%d", &dynamic_array[i]);
    }
    
    // 计算并输出平均值
    int sum = 0;
    for (int i = 0; i < n; i++) {
        sum += dynamic_array[i];
    }
    printf("平均值: %.2f\n", (float)sum / n);
    
    free(dynamic_array);  // 释放数组内存
    
    // 使用calloc分配并初始化
    int *zero_array = (int*)calloc(5, sizeof(int));
    printf("\ncalloc分配的数组(初始化为0):\n");
    for (int i = 0; i < 5; i++) {
        printf("%d ", zero_array[i]);
    }
    free(zero_array);
    
    // 使用realloc调整数组大小
    int *resize_array = (int*)malloc(3 * sizeof(int));
    resize_array[0] = 1;
    resize_array[1] = 2;
    resize_array[2] = 3;
    
    // 扩展数组大小
    resize_array = (int*)realloc(resize_array, 6 * sizeof(int));
    if (resize_array != NULL) {
        resize_array[3] = 4;
        resize_array[4] = 5;
        resize_array[5] = 6;
        
        printf("\nrealloc扩展后的数组:\n");
        for (int i = 0; i < 6; i++) {
            printf("%d ", resize_array[i]);
        }
    }
    free(resize_array);
    
    return 0;
}

字符串指针

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main() {
    // 字符串指针
    char *str1 = "Hello";  // 指向字符串常量
    char str2[] = "World"; // 字符数组
    
    printf("str1: %s\n", str1);
    printf("str2: %s\n", str2);
    
    // 动态分配字符串
    char *dynamic_str = (char*)malloc(100 * sizeof(char));
    if (dynamic_str != NULL) {
        strcpy(dynamic_str, "动态分配的字符串");
        printf("动态字符串: %s\n", dynamic_str);
        
        // 动态修改字符串
        strcat(dynamic_str, " - 已修改");
        printf("修改后: %s\n", dynamic_str);
        
        free(dynamic_str);
    }
    
    // 字符串指针数组
    char *fruits[] = {"Apple", "Banana", "Orange", "Grape"};
    int fruit_count = sizeof(fruits) / sizeof(fruits[0]);
    
    printf("\n水果列表:\n");
    for (int i = 0; i < fruit_count; i++) {
        printf("%d: %s\n", i + 1, fruits[i]);
    }
    
    return 0;
}

以上就是本篇文章的全部内容。如果您有任何问题或建议，欢迎在评论区留言讨论。