实例1：C语言基础语法
在C语言的世界里，一切从基础开始。以下是一个简单的“Hello, World!”程序，它展示了C语言的基本结构。
#include <stdio.h>
int main() {
printf("Hello, World!\n");
return 0;
}
这个程序包含了预处理指令#include <stdio.h>，它告诉编译器包含标准输入输出库。main函数是程序的入口点，printf函数用于输出文本到控制台。
实例2：变量和数据类型
变量是存储数据的容器，C语言中有多种数据类型，如整型、浮点型和字符型。
#include <stdio.h>
int main() {
int age = 25;
float salary = 5000.50;
char grade = 'A';
printf("Age: %d\n", age);
printf("Salary: %.2f\n", salary);
printf("Grade: %c\n", grade);
return 0;
}
在这个例子中，我们定义了三个变量，分别用于存储年龄、工资和成绩。
实例3：运算符
C语言提供了丰富的运算符，包括算术运算符、关系运算符和逻辑运算符。
#include <stdio.h>
int main() {
int a = 10, b = 5;
printf("Sum: %d\n", a + b);
printf("Difference: %d\n", a - b);
printf("Product: %d\n", a * b);
printf("Quotient: %d\n", a / b);
printf("Modulus: %d\n", a % b);
return 0;
}
这个例子展示了如何使用算术运算符进行基本的数学运算。
实例4：控制流——if语句
if语句用于根据条件执行代码块。
#include <stdio.h>
int main() {
int number = 10;
if (number > 0) {
printf("The number is positive.\n");
}
return 0;
}
在这个例子中，如果number大于0，程序将输出一条消息。
实例5：控制流——switch语句
switch语句用于根据变量的值执行多个代码块中的一个。
#include <stdio.h>
int main() {
int day = 3;
switch (day) {
case 1:
printf("Monday\n");
break;
case 2:
printf("Tuesday\n");
break;
case 3:
printf("Wednesday\n");
break;
default:
printf("Not a valid day.\n");
}
return 0;
}
这个例子根据day变量的值输出星期几。
实例6：循环——for循环
for循环用于重复执行一段代码，直到满足特定条件。
#include <stdio.h>
int main() {
for (int i = 1; i <= 5; i++) {
printf("Count: %d\n", i);
}
return 0;
}
这个例子使用for循环从1计数到5。
实例7：循环——while循环
while循环用于重复执行一段代码，直到条件为假。
#include <stdio.h>
int main() {
int i = 1;
while (i <= 5) {
printf("Count: %d\n", i);
i++;
}
return 0;
}
这个例子使用while循环从1计数到5。
实例8：数组
数组是存储多个相同类型数据的集合。
#include <stdio.h>
int main() {
int numbers[5] = {1, 2, 3, 4, 5};
for (int i = 0; i < 5; i++) {
printf("Number %d: %d\n", i + 1, numbers[i]);
}
return 0;
}
这个例子创建了一个包含5个整数的数组，并打印出每个元素。
实例9：指针
指针是存储变量地址的变量。
#include <stdio.h>
int main() {
int a = 10;
int *ptr = &a;
printf("Value of a: %d\n", a);
printf("Address of a: %p\n", (void *)&a);
printf("Value of ptr: %p\n", (void *)ptr);
printf("Value pointed by ptr: %d\n", *ptr);
return 0;
}
这个例子展示了如何使用指针访问变量的值和地址。
实例10：函数
函数是可重用的代码块，用于执行特定任务。
#include <stdio.h>
void greet() {
printf("Hello, World!\n");
}
int main() {
greet();
return 0;
}
这个例子定义了一个名为greet的函数，它打印出“Hello, World!”。
实例11：结构体
结构体是用于存储不同类型数据的复合数据类型。
#include <stdio.h>
struct Person {
char name[50];
int age;
float salary;
};
int main() {
struct Person employee;
strcpy(employee.name, "John Doe");
employee.age = 30;
employee.salary = 5000.00;
printf("Name: %s\n", employee.name);
printf("Age: %d\n", employee.age);
printf("Salary: %.2f\n", employee.salary);
return 0;
}
这个例子定义了一个名为Person的结构体，并创建了一个employee实例。
实例12：联合体
联合体是用于存储不同类型数据，但同一时间只能存储其中一种类型的复合数据类型。
#include <stdio.h>
union Data {
int i;
float f;
char c[4];
};
int main() {
union Data data;
data.i = 10;
printf("Integer: %d\n", data.i);
data.f = 10.5;
printf("Float: %f\n", data.f);
strcpy(data.c, "ABC");
printf("Char: %s\n", data.c);
return 0;
}
这个例子定义了一个名为Data的联合体，并展示了如何存储和访问不同类型的数据。
实例13：枚举
枚举是用于定义一组命名的整型常量的数据类型。
#include <stdio.h>
enum Weekday {
Monday,
Tuesday,
Wednesday,
Thursday,
Friday,
Saturday,
Sunday
};
int main() {
enum Weekday today = Wednesday;
printf("Today is: %d\n", today);
return 0;
}
这个例子定义了一个名为Weekday的枚举，并展示了如何使用它。
实例14：位字段
位字段是用于存储单个位的数据类型。
#include <stdio.h>
struct BitField {
unsigned int a : 1;
unsigned int b : 1;
unsigned int c : 1;
unsigned int d : 1;
unsigned int e : 1;
unsigned int f : 1;
unsigned int g : 1;
unsigned int h : 1;
};
int main() {
struct BitField bitField;
bitField.a = 1;
bitField.b = 0;
bitField.c = 1;
printf("BitField: %d\n", (bitField.a << 7) | (bitField.b << 6) | (bitField.c << 5) | (bitField.d << 4) | (bitField.e << 3) | (bitField.f << 2) | (bitField.g << 1) | bitField.h);
return 0;
}
这个例子定义了一个名为BitField的结构体，并展示了如何使用位字段。
实例15：文件操作
文件操作是C语言中重要的功能之一，以下是一个简单的文件读取示例。
#include <stdio.h>
int main() {
FILE *file = fopen("example.txt", "r");
if (file == NULL) {
printf("Error opening file.\n");
return 1;
}
char ch;
while ((ch = fgetc(file)) != EOF) {
printf("%c", ch);
}
fclose(file);
return 0;
}
这个例子打开了一个名为example.txt的文件，并读取其内容。
实例16：动态内存分配
动态内存分配允许程序在运行时分配内存。
#include <stdio.h>
#include <stdlib.h>
int main() {
int *ptr = (int *)malloc(5 * sizeof(int));
if (ptr == NULL) {
printf("Memory allocation failed.\n");
return 1;
}
for (int i = 0; i < 5; i++) {
ptr[i] = i + 1;
}
for (int i = 0; i < 5; i++) {
printf("%d ", ptr[i]);
}
free(ptr);
return 0;
}
这个例子使用malloc函数动态分配了一个整型数组，并展示了如何使用它。
实例17：字符串处理
C语言提供了丰富的字符串处理函数。
#include <stdio.h>
#include <string.h>
int main() {
char str1[50] = "Hello";
char str2[50] = "World";
char result[100];
strcpy(result, str1);
strcat(result, " ");
strcat(result, str2);
printf("Result: %s\n", result);
return 0;
}
这个例子展示了如何使用strcpy和strcat函数连接两个字符串。
实例18：输入输出
C语言提供了标准输入输出函数，如scanf和printf。
#include <stdio.h>
int main() {
int a;
float b;
printf("Enter an integer: ");
scanf("%d", &a);
printf("Enter a float: ");
scanf("%f", &b);
printf("You entered: %d and %.2f\n", a, b);
return 0;
}
这个例子展示了如何使用scanf函数读取用户输入的整数和浮点数。
实例19：结构体数组
结构体数组是存储多个结构体实例的数组。
#include <stdio.h>
struct Student {
char name[50];
int age;
float gpa;
};
int main() {
struct Student students[3];
strcpy(students[0].name, "Alice");
students[0].age = 20;
students[0].gpa = 3.5;
strcpy(students[1].name, "Bob");
students[1].age = 22;
students[1].gpa = 3.2;
strcpy(students[2].name, "Charlie");
students[2].age = 21;
students[2].gpa = 3.8;
for (int i = 0; i < 3; i++) {
printf("Name: %s, Age: %d, GPA: %.2f\n", students[i].name, students[i].age, students[i].gpa);
}
return 0;
}
这个例子定义了一个名为Student的结构体，并创建了一个包含3个学生信息的数组。
实例20：指针数组和指针数组指针
指针数组和指针数组指针是C语言中高级指针的概念。
#include <stdio.h>
int main() {
int numbers[] = {1, 2, 3, 4, 5};
int *ptrs[5];
for (int i = 0; i < 5; i++) {
ptrs[i] = &numbers[i];
}
for (int i = 0; i < 5; i++) {
printf("Number %d: %d\n", i + 1, *ptrs[i]);
}
return 0;
}
这个例子展示了如何使用指针数组和指针数组指针访问数组元素。
实例21：递归函数
递归函数是调用自身来解决问题的函数。
#include <stdio.h>
int factorial(int n) {
if (n <= 1) {
return 1;
}
return n * factorial(n - 1);
}
int main() {
int number = 5;
printf("Factorial of %d: %d\n", number, factorial(number));
return 0;
}
这个例子使用递归函数计算阶乘。
实例22：排序算法——冒泡排序
冒泡排序是一种简单的排序算法。
#include <stdio.h>
void bubbleSort(int arr[], int n) {
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
int main() {
int numbers[] = {64, 34, 25, 12, 22, 11, 90};
int n = sizeof(numbers) / sizeof(numbers[0]);
bubbleSort(numbers, n);
printf("Sorted array: ");
for (int i = 0; i < n; i++) {
printf("%d ", numbers[i]);
}
printf("\n");
return 0;
}
这个例子使用冒泡排序算法对数组进行排序。
实例23：排序算法——选择排序
选择排序是一种简单的排序算法。
#include <stdio.h>
void selectionSort(int arr[], int n) {
for (int i = 0; i < n - 1; i++) {
int min_index = i;
for (int j = i + 1; j < n; j++) {
if (arr[j] < arr[min_index]) {
min_index = j;
}
}
int temp = arr[min_index];
arr[min_index] = arr[i];
arr[i] = temp;
}
}
int main() {
int numbers[] = {64, 34, 25, 12, 22, 11, 90};
int n = sizeof(numbers) / sizeof(numbers[0]);
selectionSort(numbers, n);
printf("Sorted array: ");
for (int i = 0; i < n; i++) {
printf("%d ", numbers[i]);
}
printf("\n");
return 0;
}
这个例子使用选择排序算法对数组进行排序。
实例24：排序算法——插入排序
插入排序是一种简单的排序算法。
#include <stdio.h>
void insertionSort(int arr[], int n) {
int i, key, j;
for (i = 1; i < n; i++) {
key = arr[i];
j = i - 1;
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j = j - 1;
}
arr[j + 1] = key;
}
}
int main() {
int numbers[] = {64, 34, 25, 12, 22, 11, 90};
int n = sizeof(numbers) / sizeof(numbers[0]);
insertionSort(numbers, n);
printf("Sorted array: ");
for (int i = 0; i < n; i++) {
printf("%d ", numbers[i]);
}
printf("\n");
return 0;
}
这个例子使用插入排序算法对数组进行排序。
实例25：排序算法——快速排序
快速排序是一种高效的排序算法。
#include <stdio.h>
void swap(int *a, int *b) {
int t = *a;
*a = *b;
*b = t;
}
int partition(int arr[], int low, int high) {
int pivot = arr[high];
int i = (low - 1);
for (int j = low; j <= high - 1; j++) {
if (arr[j] < pivot) {
i++;
swap(&arr[i], &arr[j]);
}
}
swap(&arr[i + 1], &arr[high]);
return (i + 1);
}
void quickSort(int arr[], int low, int high) {
if (low < high) {
int pi = partition(arr, low, high);
quickSort(arr, low, pi - 1);
quickSort(arr, pi + 1, high);
}
}
int main() {
int numbers[] = {64, 34, 25, 12, 22, 11, 90};
int n = sizeof(numbers) / sizeof(numbers[0]);
quickSort(numbers, 0, n - 1);
printf("Sorted array: ");
for (int i = 0; i < n; i++) {
printf("%d ", numbers[i]);
}
printf("\n");
return 0;
}
这个例子使用快速排序算法对数组进行排序。
实例26：链表
链表是一种动态数据结构，用于存储一系列元素。
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node *next;
};
void insertAtBeginning(struct Node **head_ref, int new_data) {
struct Node *new_node = (struct Node *)malloc(sizeof(struct Node));
new_node->data = new_data;
new_node->next = (*head_ref);
(*head_ref) = new_node;
}
void printList(struct Node *node) {
while (node != NULL) {
printf("%d ", node->data);
node = node->next;
}
printf("\n");
}
int main() {
struct Node *head = NULL;
insertAtBeginning(&head, 1);
insertAtBeginning(&head, 2);
insertAtBeginning(&head, 3);
printList(head);
return 0;
}
这个例子展示了如何创建一个链表，并在其开头插入元素。
实例27：栈
栈是一种后进先出（LIFO）的数据结构。
”`c
#include