欢迎您访问 最编程 本站为您分享编程语言代码，编程技术文章！

热门搜索/Hot Search

您现在的位置是： 首页

10 万字的 C 语言入门手册，历时三个月，详尽的 C 语言教程终于面世，给你全新的 C 语言入门体验！

最编程 2024-04-22 16:20:39
...

C语言是一种非常流行的编程语言，它是许多现代编程语言的基础。

什么是计算机？

计算机是一种用于存储、处理、和输出数据的电子设备。它通过程序控制和数学算法来实现数据处理。计算机通过输入设备（如键盘、鼠标）接收命令，然后通过输出设备（如显示器、打印机）显示结果。计算机是用于处理各种任务的重要工具，如游戏、数据分析、信息检索等。

C语言程序由以下组成部分构成：

  1. 预处理指令：这些指令是编译器处理的第一步，它们告诉编译器如何处理代码。例如，预处理指令可以用来包含头文件或定义常量。

  2. 函数：函数是程序的主要部分，它们执行特定的任务。C语言中的每个程序都必须包含一个主函数，其他函数可以根据需要定义。

  3. 变量和常量：变量是程序中存储数据的地方，常量是一种固定值，不能在程序执行过程中更改。

  4. 语句：语句是程序的基本单元，用于执行特定的操作。例如，赋值语句用于给变量赋值，控制语句用于控制程序流程。

  5. 数据类型：数据类型指定了变量存储的数据类型，例如整数、字符串等。

这些组成部分结合在一起，组成了完整的C语言程序。当程序编译和执行时，编译器会执行这些组成部分，最终完成程序的执行。

C语言函数的定义格式如下：

return_type function_name(parameter_list)
{
   /* 函数体 */
   statement1;
   statement2;
   ...
   return value;
}

其中：

  • return_type是函数的返回类型，如果函数没有返回任何值，则使用void关键字。

  • function_name是函数的名称，必须是有效的C语言标识符。

  • parameter_list是一个可选的参数列表，用于向函数传递值。

  • 函数体是一个括号括起来的代码块，包含了函数的执行语句。

  • return value是可选的，用于返回值给调用函数的语句。

举个例子，下面是一个求两个数的和的函数的定义：

int sum(int a, int b)
{
   int result;
   result = a + b;
   return result;
}

定义好的函数可以在其他代码中被调用。调用函数的语法如下：

function_name(argument1, argument2, ...);

其中，function_name是函数的名称，argument1, argument2, ...是函数的参数列表。函数调用时，程序会跳转到函数的定义处执行其语句。

例如，如果定义了一个求两个数的和的函数，则可以在其他代码中这样调用：

#include <stdio.h>

int sum(int a, int b)
{
   int result;
   result = a + b;
   return result;
}

int main()
{
   int num1, num2, result;
   printf("Enter two numbers: ");
   scanf("%d %d", &num1, &num2);
   result = sum(num1, num2);
   printf("Sum of %d and %d is %d", num1, num2, result);
   return 0;
}

在这段代码中，sum函数被调用两次，用于求两个数的和，并将结果存储在变量result中。

编写好的C语言程序需要经过编译和链接才能运行。

编译程序的过程是将C语言代码转换为可执行文件的过程。最常见的C语言编译器是GNU C Compiler（gcc）。注意：这里举例gcc编译器只是作为例子说明，实际编程应选择当前受欢迎的编译器。使用gcc编译程序的命令如下：

gcc -o output_file input_file.c

其中，input_file.c是源代码文件，-o output_file是指定生成的可执行文件的名称。

链接程序的过程是将多个目标文件和库文件链接在一起，生成一个单独的可执行文件的过程。

运行程序的命令如下：

./output_file

其中，output_file是编译后生成的可执行文件的名称。

例如，如果有一个源代码文件test.c，则可以这样编译和运行：

gcc -o test test.c
./test

main函数是C语言程序的入口，它是程序的主函数。

常见的写法如下：

int main(void)
{
    /* 程序代码 */
    return 0;
}

或者：

int main(int argc, char *argv[])
{
    /* 程序代码 */
    return 0;
}

其中：

  • int表示main函数的返回值是整数，一般返回0表示程序正常结束，非0的数字表示程序异常结束。
  • void表示main函数没有参数。
  • int argc是参数个数，包括程序名称在内的所有参数。
  • char *argv[]是一个指向字符串的指针数组，用于存储所有参数，其中argv[0]是程序名称。

需要注意的是：

  • main函数必须是整个程序中唯一的，不能在程序中定义多个main函数。
  • 不同编译器对main函数的支持可能有所差异，请遵循对应的编译器的要求。
  • 参数的使用方式需要在编写程序时进行特别的考虑，以确保程序可以正确处理参数。

学习C语言编程最好的方法之一是编写练习程序。下面是一些简单的C语言编程练习，你可以从中选择一个开始：

打印"Hello, World!"到屏幕上。

#include <stdio.h>

int main(void)
{
    printf("Hello, World!\n");
    return 0;
}

求两个数字的和并输出结果

#include <stdio.h>

int main(void)
{
    int a, b, c;

    printf("请输入两个数字：");
    scanf("%d%d", &a, &b);

    c = a + b;
    printf("两个数字的和为：%d\n", c);

    return 0;
}

计算圆的面积

#include <stdio.h>
#include <math.h>

int main(void)
{
    double r, area;
    const double pi = 3.14159265358979323846;

    printf("请输入圆的半径：");
    scanf("%lf", &r);

    area = pi * pow(r, 2);
    printf("圆的面积为：%.2lf\n", area);

    return 0;
}

使用循环语句打印九九乘法表

#include <stdio.h>

int main(void)
{
    int i, j;

    for (i = 1; i <= 9; i++)
    {
        for (j = 1; j <= i; j++)
        {
            printf("%d * %d = %d\t", j, i, i * j);
        }
        printf("\n");
    }

    return 0;
}

这些练习程序可以帮助你学习C语言的基本语法，同时加深对C语言的理解。

初学者如何避免程序出现BUG：

  1. 细心：在编写代码时，要仔细检查语法和格式，确保代码没有错误。

  2. 认真读题：在编写代码之前，要仔细阅读题目，了解题目的要求。

  3. 注释代码：注释代码可以帮助你清晰地理解代码，并且方便以后回顾代码。

  4. 利用调试工具：如果代码出现问题，你可以使用调试工具，如GDB或Visual Studio，帮助你找出错误。

  5. 测试代码：在编写完代码后，要测试代码的正确性，确保代码满足题目要求。

  6. 寻求帮助：如果你不确定代码是否正确，你可以寻求帮助，如在线社区或导师。

通过遵循这些步骤，你可以减少程序出现BUG的概率，提高编写代码的效率和准确性。

各种语言的例子：

C语言：

#include <stdio.h>

int main() {
    printf("Hello, World!\n");
    return 0;
}

C++

#include <iostream>

int main() {
    std::cout << "Hello, World!" << std::endl;
    return 0;
}

Java

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

Python

print("Hello, World!")

JavaScript

console.log("Hello, World!");

以上代码均为打印“Hello, World!”的示例，可以作为学习每种语言的起点。

在编程语言中，注释是一段文本，其内容不会被编译器或解释器执行，而是用来向其他人或者自己提供说明、说明代码的意图和作用的文字。它的目的是帮助程序员理解代码，也方便以后代码的维护和修改。

注释可以写在代码的任意位置，并不影响代码的正常运行。

在C语言中，注释可以使用两种方式：

  1. 单行注释：在注释内容前面加上//
  2. 多行注释：在注释内容前面加上/*，在注释内容后面加上*/

注释在编程中有以下几种常见的应用场景：

  1. 声明变量：在定义变量时可以写上注释，说明变量的用途和取值范围。

  2. 说明代码的意图：在代码中可以写上注释，说明该段代码的作用，帮助程序员理解代码。

  3. 忽略代码：当需要忽略某段代码时，可以使用注释，该段代码不会被执行。

  4. 代码版本控制：在程序中加入注释，说明程序的版本，方便以后回溯。

  5. 调试代码：在调试代码时，可以使用注释说明代码的问题，帮助调试。

注释是编程中非常有用的工具，它不仅有助于程序员理解代码，还有助于以后代码的维护和修改。因此，在编写代码时，应该积极使用注释。

关键字（Keyword）是指在某一编程语言中已经预定义好的、不能被用作其他意义的标识符（Identifier）。关键字通常具有特殊的含义，不能作为变量名、函数名、常量名等来使用。例如，在C语言中，"int"、"float"、"while"等都是关键字。

关键字是编程语言的一部分语法，它们用于实现编程语言中的特殊功能，如循环、判断、函数调用等。因此，在编写代码时，应该遵循关键字的使用规则，正确使用关键字，才能保证代码的正确性。

关键字可以分为以下几类：

  1. 数据类型关键字：如int、float、double等，用于定义变量的数据类型。

  2. 控制结构关键字：如if、else、switch、case等，用于控制程序的流程。

  3. 循环结构关键字：如for、while、do-while等，用于实现循环语句。

  4. 函数相关关键字：如return、void、main等，用于定义函数的返回值类型、参数类型以及主函数的定义。

  5. 其他关键字：如const、static、register等，用于实现更多的功能，如定义常量、修饰符等。

不同的编程语言有不同的关键字，但是以上分类是公共的。对于初学者，需要掌握每种语言的关键字，并且要熟练使用。

标识符是程序员用来命名变量、常量、函数、数组、结构体、枚举等程序元素的字符串。标识符是用于区分不同元素的名称，以便程序员能够对其进行引用、调用等操作。

标识符的命名规则通常有以下几个：

  1. 标识符只能由字母、数字和下划线构成，不能以数字开头。

  2. 标识符的长度不受限制，但是建议使用简短而易于理解的名称。

  3. 不能使用关键字作为标识符名称。

  4. 不同语言对于标识符大小写敏感的程度不同，某些语言的标识符大小写敏感，而某些语言的标识符大小写不敏感。

标识符的命名方式有不同的编程规范，如驼峰式命名法、下划线命名法等，但是不同的编程规范不同的语言中都有着广泛的使用。

以下是一些示例的合法标识符：

  1. myVariable
  2. _private
  3. count123
  4. student_name
  5. salaryRate

以下是一些不合法的标识符：

  1. 123count (不能以数字开头)
  2. for (与关键字重名)
  3. float# (不能包含特殊字符)
  4. class (与关键字重名)
  5. void! (不能包含特殊字符)

请注意，上述合法标识符的定义可能因语言而异。

标识符命名规范通常有以下几点：

  1. 只能使用字母、数字和下划线（_）等字符，不能使用特殊字符或空格。
  2. 不能以数字开头，通常以字母开头。
  3. 不能与关键字重名。
  4. 避免使用单字母标识符。
  5. 避免使用与现有数学、物理、化学符号相似的标识符。
  6. 使用有意义且易于理解的标识符名称。
  7. 遵循一致的命名约定，例如使用驼峰式命名法或下划线分隔命名法。

遵循这些规范可以使代码易于阅读、理解和维护。

数据是计算机科学中的一个术语，指代码程序处理、存储或传输的任何信息。它可以是文本、图像、音频、视频、数字或任何其他形式的数据。

数据是计算机程序的基础，是程序运行的输入和输出。它可以用不同的数据类型表示，例如整数、字符串、浮点数等。程序必须对数据进行合适的处理，才能得到预期的结果。

数据通常可以分为以下几类：

  1. 数字型数据：包括整数和浮点数，用于表示数字。

  2. 字符型数据：用于表示单个字符或字符串，如字母、数字、符号等。

  3. 布尔型数据：用于表示真假，通常只有两个值：真和假。

  4. 枚举类型数据：是一种特殊的整数类型，定义了一组名称，用于表示一组有限的常量。

  5. 结构体数据：用于表示复合数据类型，由一组数据元素组成，可以是任意数据类型。

  6. 数组数据：是一组相同类型的数据元素，组成的有序集合。

  7. 指针数据：是一种特殊的数据类型，用于表示内存中的地址。

这是常见的数据类型，不同的语言可能存在差异。此外，数据类型还可以扩展，以满足特定的需求。

常量是程序编写过程中，用固定值代替的数据，它的值在整个程序执行过程中不变。常量在程序中的值只能被编译器读入，不能在程序执行过程中再次改变。C语言中定义常量有多种方法，如#define、const等。常量主要用于在程序中表示固定不变的数值，提高代码的可读性，便于代码维护。

C语言中的常量可以分为以下几种类型：

  1. 字符常量：字符常量是用单引号括起来的单个字符，例如'A'、'a'等。

  2. 字符串常量：字符串常量是用双引号括起来的字符序列，例如"hello"、"world"等。

  3. 整数常量：整数常量是一个没有小数部分的整数值，可以是十进制、八进制或十六进制。例如100、0755、0xFF等。

  4. 实数常量：实数常量是一个有小数部分的数值，例如3.14、-0.01等。

  5. 符号常量：符号常量是使用#define预处理指令定义的常量，例如#define PI 3.1415926。

不同类型的常量在使用时有不同的语法和限制，因此在使用常量时需要注意数据类型的正确性。

变量是计算机程序中一种用于存储数据的容器。变量的值可以在程序的执行过程中改变，其名称与其所存储的数据值相关联。每个变量都有一个类型，类型决定了变量所存储的数据类型，如整数、浮点数、字符等。

在 C 语言中，变量是通过使用关键字 var 或类型说明符来定义的。下面是定义变量的语法：

​
var_type variable_name;

​

其中 var_type 是变量的类型，如 int、float、double、char 等；variable_name 是变量的名称。

例如，如果你想定义一个名为 age 的整数变量，代码如下：

int age;

同样，你可以定义多个变量，例如：

int x, y, z;
float f1, f2;
char c1, c2, c3;

在定义变量时，你还可以为其初始化，例如：

int x = 10;
float f1 = 3.14;
char c1 = 'A';

在 C 语言中，变量的值可以通过两种方式使用：读取和赋值。

读取变量：可以在程序中读取变量的值，例如：

int x = 10;
printf("The value of x is %d\n", x);

在上面的代码中，变量 x 的值被读取并打印到屏幕上。

赋值变量：可以在程序中将新值赋给变量，例如：

int x = 10;
x = 20;
printf("The value of x is %d\n", x);

在上面的代码中，变量 x 的值被赋为 20，然后打印到屏幕上。

请注意，在赋值操作中，左边的变量必须已经定义，并且新值的数据类型必须与变量的数据类型相匹配。

变量的初始化指的是给变量赋予一个初始值，在定义变量的同时进行初始化，或者在使用变量之前进行初始化。这个初始值可以是字面量、常量、表达式等。如下是一个初始化的示例：

int num = 10;
char letter = 'A';

在 C 语言中，未经初始化的变量有一个默认值，但这不是好的编程习惯，因为这可能会导致意想不到的结果。强烈建议在定义变量时立即进行初始化。

可以通过赋值语句来修改变量的值。赋值语句的语法如下：

变量名 = 表达式;

例如：

int num = 10;
num = 20;

在这个例子中，num 的值从 10 变为 20。

此外，也可以使用一些运算符来修改变量的值，例如：

num += 10; // num 的值现在为 30
num *= 2; // num 的值现在为 60

通过运算符的使用，可以在变量的当前值的基础上进行更新。

变量之间的值传递指的是在程序运行过程中，通过函数调用或其他方式，将一个变量的值传递给另一个变量。

在 C 语言中，变量的值传递可以通过两种方式：值传递和指针传递。值传递即将变量的值复制到函数的参数中，任何对参数的修改不影响原变量的值。指针传递则是通过指针传递变量的地址，函数可以通过访问该地址来修改原变量的值。

通过明确的定义，可以控制变量之间的值传递，避免出现意外的结果。

#include <stdio.h>

void swap(int *x, int *y)
{
    int temp = *x;
    *x = *y;
    *y = temp;
}

int main()
{
    int a = 10, b = 20;
    printf("Before swap: a = %d, b = %d\n", a, b);
    swap(&a, &b);
    printf("After swap: a = %d, b = %d\n", a, b);
    return 0;
}

在这个示例中，我们在main函数中定义了两个变量a和b，并将它们的值初始化为10和20。接着，我们调用了swap函数，并将变量a和b的地址作为参数传递。在swap函数内部，我们定义了一个临时变量temp，用来保存变量x的值。然后我们通过指针交换了两个变量的值。最后，我们再次打印了这两个变量的值，以验证交换是否成功。

执行这段代码将会输出：

Before swap: a = 10, b = 20
After swap: a = 20, b = 10

通过这个示例，我们可以看到，通过指针传递变量的值，我们可以在函数中对变量的值进行操作。

在 C 语言中，可以使用 printf 函数查看变量的值。在 printf 函数的格式字符串中，使用 %d 或 %f 输出整数或浮点数，分别表示当前变量的值。例如：

int x = 10;
float y = 3.14;
printf("x 的值是：%d\n", x);
printf("y 的值是：%f\n", y);

在这个例子中，第一个 printf 函数输出整数变量 x 的值，第二个 printf 函数输出浮点数变量 y 的值。

变量的作用域指的是变量在程序中的生效区域，即变量能在程序中的哪些地方被使用和访问。

C语言中的变量有两种作用域：全局作用域和局部作用域。

全局作用域：全局作用域的变量定义在函数外部，对于整个程序都有效。

局部作用域：局部作用域的变量定义在函数内部，只在函数内部有效，函数外部不能访问。

注意：同一作用域内的变量不能重名，否则会出现错误。

变量内存分析是一个关于程序的存储机制的概念。每个变量在内存中都有一个对应的存储位置，该位置存储了变量的值。在C语言中，内存是以字节为单位进行管理的，每个变量占用的存储空间大小取决于其类型。

变量的内存管理可以通过几种不同的方式进行，比如全局变量和局部变量，静态变量和动态变量。全局变量和静态变量在整个程序中都有效，而局部变量和动态变量只在它们声明的范围内有效。

printf 函数是 C 语言中常用的输出函数，用于将消息输出到屏幕。它在标准输出库 (stdio.h) 中定义，可以在程序中通过使用以下语句来使用它：

#include <stdio.h>

 

printf 函数的语法如下：

int printf(const char *format, ...);

参数 format 是一个控制字符串，告诉函数如何格式化输出。随后的可选参数指定要输出的值。

例如：

printf("Hello World!");

输出：

Hello World!

在 printf 函数中，可以使用一些特殊字符（称为转换说明符）来格式化输出，如：%d（十进制整数），%f（浮点数），%c（字符）等。

例如：

#include <stdio.h>

int main()
{
   int number = 100;
   float decimal = 3.14159;
   char character = 'A';

   printf("The integer is: %d\n", number);
   printf("The decimal is: %f\n", decimal);
   printf("The character is: %c\n", character);

   return 0;
}

输出：

The integer is: 100
The decimal is: 3.14159
The character is: A

Scanf函数是一个从标准输入（通常是键盘）读取数据的函数，它的完整语法如下：

int scanf(const char *format, ...);

format是一个字符串，代表要读取的数据的格式。它的定义和printf函数的格式字符串是类似的，例如：

%d 读取一个十进制整数
%f 读取一个十进制浮点数
%s 读取一个字符串

其它的格式字符串的定义也和printf函数是一样的。

scanf函数返回读取的数据项数，如果出现错误，则返回EOF（-1）。

例如：

int age;
printf("请输入您的年龄：");
scanf("%d", &age);
printf("您的年龄是：%d\n", age);

在这个例子中，scanf函数从标准输入读取了一个整数，并将它存储在变量age中。

scanf函数是用于读入输入数据的C语言标准库函数。scanf函数的工作原理是：它从标准输入（通常是键盘）读入数据，根据提供的格式字符串来分析输入数据，然后将数据存储到指定的变量中。

格式字符串是控制scanf函数读入数据的方式的字符串，例如：%d 表示读入一个整数，%f 表示读入一个浮点数，%c 表示读入一个字符，等等。

在scanf函数执行过程中，它一直等待输入，直到遇到一个空格、回车或者制表符为止，这些字符是scanf函数的分隔符，用于区分输入的不同数据。

scanf函数的返回值是实际读入的数据数量，如果读入数据失败或者发生错误，则返回 EOF。

putchar 函数和 getchar 函数是 C 语言中的标准输入/输出函数。

putchar 函数可以将单个字符输出到标准输出设备，常用于将字符逐一输出。例如：

#include <stdio.h>

int main() {
    int c;
    while ((c = getchar()) != EOF) {
        putchar(c);
    }
    return 0;
}

getchar 函数则可以从标准输入设备（通常是键盘）读入单个字符，常用于读入字符串。例如：

#include <stdio.h>

int main() {
    int c;
    while ((c = getchar()) != EOF) {
        putchar(c);
    }
    return 0;
}

putchar 和 getchar 在交互式编程中很常用，但是在实际项目开发中，通常会使用更高级的输入输出函数，如 printf 和 scanf。

运算符是一种特殊的符号，它对数据进行操作。C语言提供了多种运算符，如算术运算符、关系运算符、逻辑运算符、位运算符等。它们可以用于求值、判断关系、逻辑判断、二进制位操作等。运算符运算后会得出一个结果，结果可以是数字、布尔值等。

C语言中的运算符可以分为以下几类：

  1. 算术运算符：包括加法、减法、乘法、除法、取模等。

  2. 关系运算符：包括大于、小于、等于、不等于等。

  3. 逻辑运算符：包括与、或、非等。

  4. 赋值运算符：用于把一个值赋给一个变量。

  5. 位运算符：包括位与、位或、位异或、左移、右移等。

  6. 三目运算符：可以根据条件来选择不同的表达式。

  7. 逗号运算符：用于多个表达式的组合。

  8. 自增自减运算符：用于对变量的值进行加一或减一操作。

算术运算符

int a = 5, b = 10;
int c = a + b; // c = 15
int d = b - a; // d = 5
int e = a * b; // e = 50
int f = b / a; // f = 2
int g = b % a; // g = 0

关系运算符

int a = 5, b = 10;
int c = (a < b); // c = 1
int d = (a > b); // d = 0
int e = (a == b); // e = 0
int f = (a != b); // f = 1

逻辑运算符

int a = 1, b = 0;
int c = (a && b); // c = 0
int d = (a || b); // d = 1
int e = !a; // e = 0

赋值运算符

int a = 5;
a += 2; // a = 7
a -= 2; // a = 5
a *= 2; // a = 10
a /= 2; // a = 5
a %= 2; // a = 1

运算符的优先级决定了表达式中的操作先后顺序，在一个表达式中，具有较高优先级的运算符将先于具有较低优先级的运算符执行。结合性决定了表达式中相同优先级的运算符的求值顺序。

C语言中有一个优先级表，该表描述了不同运算符的优先级，通常在编写代码时，可以参考该表。如果需要明确定义一个表达式的求值顺序，可以使用括号。

例如：

在表达式 2 + 3 * 4 中，* 运算符的优先级高于 + 运算符，因此 3 * 4 将首先被计算，结果为 12，然后 2 和 12 将被相加，得到最终结果 14。

在表达式 (2 + 3) * 4 中，括号明确指示了 2 和 3 的加法应该首先被计算，得到结果 5，然后再将 5 和 4 进行乘法运算，得到最终结果 20。

算数运算符是指对两个操作数进行数学计算的运算符，例如加法运算符（+），减法运算符（-），乘法运算符（*），除法运算符（/）等。在 C 语言中，算数运算符的结果可以是整数或浮点数。例如：

int a = 3, b = 4;
int c = a + b;
float d = (float)a / b;

在上面的代码中，c 的值为 7，d 的值为 0.75。

赋值运算符是用来给变量赋值的运算符。在C语言中，赋值运算符是“=”，表示左边的变量等于右边的值或表达式的值。例如：

int x;
x = 10;

上面的代码定义了一个整型变量x，然后通过赋值运算符给它赋值为10。

需要注意的是，赋值运算符有右结合性，也就是说从右往左计算。例如：

int x, y;
x = y = 10;

上面的代码表示先给变量y赋值为10，然后再给变量x赋值为y的值，即10。

自增自减运算符是一种特殊的赋值运算符，它可以简化变量的值的更改过程。

在 C 语言中，有两个自增自减运算符：

  • ++：在变量的值上加 1。
  • --：在变量的值上减 1。

例如：

#include<stdio.h>

int main()
{
    int num = 10;
    printf("num = %d\n", num);  // 输出 num = 10
    num++;                       // num = num + 1，现在 num 的值为 11
    printf("num = %d\n", num);  // 输出 num = 11
    num--;                       // num = num - 1，现在 num 的值为 10
    printf("num = %d\n", num);  // 输出 num = 10
    return 0;
}

可以看到，使用自增自减运算符可以方便的改变变量的值。在 C 语言中，自增自减运算符可以和其他运算符一起使用，也可以作为独立的语句使用。

sizeof 运算符是用于求变量或类型的大小（以字节为单位）的运算符。可以使用 sizeof 运算符来确定内存空间的大小，从而决定存储变量所需的空间。下面是一个使用 sizeof 运算符的简单示例：

#include <stdio.h>
 
int main()
{
   int a;
   float b;
   double c;
 
   printf("Size of int: %d bytes\n", sizeof(a));
   printf("Size of float: %d bytes\n", sizeof(b));
   printf("Size of double: %d bytes\n", sizeof(c));
 
   return 0;
}

运行上面的代码将会打印出整数、浮点数和双精度浮点数在机器上占用的字节数。

逗号运算符是C语言中的一种运算符，它的作用是将两个表达式进行分隔，并将后一个表达式的值作为整个逗号表达式的值返回。

举个例子：

int x, y;
x = (y=3, y+2);
printf("x=%d, y=%d", x, y);

在上面的代码中，逗号表达式的左边是y=3，右边是y+2，因此y的值先变为3，然后整个逗号表达式的值为y+2的值，即5，因此x的值也变为5。输出结果为x=5, y=3。

注意：逗号运算符是一种比较特殊的运算符，它具有较低的优先级，在一些特殊的场景下，需要特别注意它的使用方法。

关系运算符用于比较两个数的大小关系，并返回布尔值（真/假）。常见的关系运算符有：

  • >：大于
  • <：小于
  • >=：大于等于
  • <=：小于等于
  • ==：等于
  • !=：不等于

例如：

#include <stdio.h>

int main()
{
    int a = 5, b = 10;
    printf("%d > %d: %d\n", a, b, a > b);
    printf("%d < %d: %d\n", a, b, a < b);
    printf("%d >= %d: %d\n", a, b, a >= b);
    printf("%d <= %d: %d\n", a, b, a <= b);
    printf("%d == %d: %d\n", a, b, a == b);
    printf("%d != %d: %d\n", a, b, a != b);
    return 0;
}

输出结果：

5 > 10: 0
5 < 10: 1
5 >= 10: 0
5 <= 10: 1
5 == 10: 0
5 != 10: 1

这里的%d是指输出的是整数，而0代表false，1代表true。

逻辑运算符用于比较两个值的关系并返回布尔值（真或假）。常用的逻辑运算符包括：

  1. && (逻辑与)：如果两个操作数均为真，则结果为真；

  2. || (逻辑或)：如果两个操作数中有一个为真，则结果为真；

  3. ! (逻辑非)：对单个操作数取反，如果为真则结果为假，反之亦然。

例如：

if ( (a > b) && (c < d) ) {
  printf("a is greater than b and c is less than d\n");
}

if ( (x == y) || (z != 0) ) {
  printf("x is equal to y or z is not equal to zero\n");
}

在上面的例子中，逻辑运算符用于比较两个值并决定是否执行 if 语句中的代码块。

三目运算符（ternary operator）是一种条件运算符，它的语法格式如下：

condition ? expression1 : expression2

当 condition 为真时，三目运算符的结果为 expression1；当 condition 为假时，三目运算符的结果为 expression2。

例如：

int x = 10, y = 20;
int max = x > y ? x : y;

在这个例子中，当 x 大于 y 时，max 的值为 x；当 x 不大于 y 时，max 的值为 y。

类型转换是指将一种数据类型的变量或常量转换为另一种数据类型的过程。通常情况下，编程语言会提供一些内置的函数（如 C 语言中的 atoi，atof 等）或运算符（如 C 语言中的强制类型转换符）来实现数据类型转换。

例如，在 C 语言中，如果想要将一个 int 类型的数转换为 float 类型，可以使用强制类型转换符：

int x = 10;
float y = (float) x;

类型转换的结果可能导致数据的精度或数据丢失，所以类型转换的时候需要特别小心。

完成一些编程题目。这样可以帮助练习编写代码，并且可以测试对语言的理解程度。一些免费的编程题目网站包括：LeetCode, HackerRank, Codewars, CodeForces等。也可以练习编写小型项目，例如：控制台应用程序，网页或游戏。

流程控制是指在程序执行过程中，根据特定条件决定程序的执行路径，从而实现程序的逻辑控制。流程控制有助于使程序的执行更加灵活和高效。在编程语言中，流程控制主要通过语句（如if语句，for循环等）实现。

选择结构是程序设计的一种基本结构，它允许程序在特定情况下根据条件执行不同的语句。通常，选择结构是使用if语句实现的，它允许程序在满足特定条件时执行一组语句。

例如：

if (age > 18)
{
   printf("Adult");
}
else
{
   printf("Minor");
}

在上面的示例中，程序会根据age的值来决定是否执行printf("Adult")。如果age大于18，则执行printf("Adult")；否则，执行printf("Minor")。

Switch 语句是一种分支语句，用于多路判断一个表达式，以选择合适的执行路径。语法格式如下：

switch(expression) 
{ 
    case constant-expression : 
        statement(s); 
        break; 
    case constant-expression : 
        statement(s); 
        break; 
    default : 
        statement(s); 
}

其中，expression是需要被判断的表达式， constant-expression 是比较的常量值， statement(s) 是执行的语句， default 块是当表达式与所有 case 常量不匹配时的语句块，break是结束语句块的关键字。

switch 语句的工作原理是：把 expression 的值与各个 case 常量值进行匹配，如果有一个匹配，那么执行与该常量对应的语句块，直到遇到 break 语句或者 switch 语句结束。

循环结构是一种重复执行指定代码的程序结构。它控制程序的执行，使某段代码能够多次执行。常见的循环结构有for循环，while循环和do-while循环。循环结构是控制程序流程的重要工具，能够有效地实现代码的重复执行。

while循环是一种常用的循环结构，它可以在满足特定条件时重复执行某段代码。在while循环中，先对循环条件进行判断，如果满足条件，则循环体内的代码将被重复执行，否则退出循环。

语法格式如下：

while (condition) {
// loop body
}

其中，condition是循环条件，当它为真时，循环体内的代码将被重复执行，循环条件可以是任意的布尔表达式；循环体内的代码可以是任意的语句。

do-while循环结构是一种特殊的循环结构，它保证循环体至少被执行一次。do-while循环的语法如下：

do
{
statement(s);
} while (condition);
  • 关键字do开始了循环，while结束了循环。
  • 循环体（statement(s)）可以是一个语句或语句块，在每次循环过程中执行。
  • 循环条件（condition）是一个布尔表达式，如果它的值为真，循环将继续执行；如果它的值为假，循环将终止。

例子：

#include <stdio.h>

int main()
{
    int i = 1;
    do
    {
        printf("%d\n", i);
        i++;
    } while (i <= 5);
    return 0;
}

该代码打印了1到5的数字，因为循环体始终执行一次，所以即使循环条件为假，也将执行一次。

For循环是一种常用的循环结构，其语法如下：

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

for循环的工作原理是：首先执行初始化语句，然后判断循环条件，如果成立，则执行循环体，最后执行更新语句。循环条件判断后不成立，则终止循环。

初始化语句一般是用来设置循环变量的初始值；循环条件是控制循环继续执行的条件；更新语句用来更新循环变量，使得循环可以继续进行。

以下是一个使用 for 循环的示例：

#include <stdio.h>

int main()
{
    int i;
    for (i = 1; i <= 10; i++)
    {
        printf("%d\n", i);
    }
    return 0;
}

运行后的输出：

1
2
3
4
5
6
7
8
9
10

在这个示例中，for 循环被用于输出 1 到 10 的整数。它初始化 i 为 1，当 i 小于等于 10 时，循环继续执行，否则循环结束。在每次循环中，i 的值递增 1，最后 i 被赋值为 11。

四大跳转是指四种不同的跳转语句：break，continue，goto 和 return。

  1. break语句可以终止所在的循环结构或者 switch 语句。

  2. continue语句会跳过循环的剩下部分，控制权会返回到循环语句的顶部。

  3. goto语句会在程序中跳到标记的语句，而不管在此之前的语句是否执行。

  4. return语句用于终止函数的执行，并返回一个值（如果需要）给函数调用者。

循环的嵌套是指在一个循环内部还嵌套了另一个循环。这种结构可以让我们在处理多维数据结构时方便许多。

例如，我们要打印一个乘法表，在外层循环中控制行，在内层循环中控制列。

#include <stdio.h>

int main()
{
    int i, j;
    for (i = 1; i <= 9; i++) {
        for (j = 1; j <= i; j++) {
            printf("%d*%d=%d\t", j, i, i * j);
        }
        printf("\n");
    }
    return 0;
}

该程序的输出结果是：

1*1=1
1*2=2	2*2=4
1*3=3	2*3=6	3*3=9
1*4=4	2*4=8	3*4=12	4*4=16
1*5=5	2*5=10	3*5=15	4*5=20	5*5=25
1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36
1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49
1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64
1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81

通过循环的嵌套，我们实现了对乘法表的打印，大大简化了代码的复杂度。

图形打印是一种使用计算机编程技术打印图形的技术，通常是在控制台或者图形界面上实现。常见的图形有：矩形、三角形、星形、菱形等。

举个例子，如果想要打印一个长方形，可以使用如下代码：

#include <stdio.h>

int main() {
    int i, j;
    for (i = 0; i < 5; i++) {
        for (j = 0; j < 10; j++) {
            printf("*");
        }
        printf("\n");
    }
    return 0;
}

执行以上代码后，将会在控制台输出一个长度为10，高度为5的长方形，每行输出10个星号。

通过使用循环和条件语句，可以很容易的实现各种图形的打印。

函数是在C语言编程中一个非常重要的概念。函数是一段独立的程序代码，用于完成特定的任务，可以被其他程序代码调用。通过使用函数，我们可以将大的程序拆分成许多小的函数，从而更加方便地编写、维护和修改程序代码。函数有输入参数和返回值，用于在函数之间传递信息和数据。

函数可以分为以下几类：

  1. 内置函数：由编译器提供的一些常用函数，如 printf 和 scanf。

  2. 用户自定义函数：由用户自己编写的函数，它们可以是标准函数或是特殊函数。

  3. 预处理函数：是一种特殊的函数，在程序编译前进行处理，如 #define 和 #include。

  4. 库函数：由 C 语言编程语言提供的一些预先编写的函数，可以直接使用，如 math.h 库。

函数是一段可以被多次调用的独立的代码块，它接受一些参数并返回一个值。函数的定义包括函数名、参数列表和函数体。在 C 语言中，函数定义的语法如下：

return_type function_name (parameter list)
{
   body of the function
}
  • return_type 是函数返回值的数据类型。如果函数不需要返回任何值，可以使用 void 作为返回类型。
  • function_name 是函数的名称，同样遵循 C 语言的命名规则。
  • parameter list 是函数的参数列表，指定了函数需要的输入。如果函数不需要任何参数，则参数列表可以为空。
  • body of the function 包含了函数的执行代码，通过调用函数来实现执行。

举个例子：

#include <stdio.h>

int max(int num1, int num2)
{
   int result;
   if (num1 > num2)
      result = num1;
   else
      result = num2;
   return result;
}

int main()
{
   int a = 100;
   int b = 200;
   int ret;
   ret = max(a, b);
   printf("Max value is : %d\n", ret);
   return 0;
}

在这个示例中，我们定义了一个名为 max 的函数，它接受两个整数作为参数，并返回这两个整数中的较大值。在 main 函数中，我们调用了 max 函数，并将结果保存在 ret 变量中。

函数的参数和返回值是指函数与外部世界的通信方式。

函数的参数是指在调用函数时，向函数传递的信息，用于告诉函数具体做什么。函数的返回值是指函数运行完毕后返回给外部的信息。

举个例子：

设计一个函数叫做 add，这个函数需要两个参数 a 和 b，函数内部将 a 和 b 相加，返回和值。

int add(int a, int b)
{
    int sum = a + b;
    return sum;
}

在这个例子中，函数 add 的参数是 a 和 b，它们是函数与外部世界的通信通道。在运行时，调用该函数时向其传递的值作为 a 和 b 值，并且将这两个值相加，最后返回和值作为函数的返回值。

在 C 语言中，函数的声明（也称为函数原型）是一种告诉编译器关于函数的特定信息的方式。它提供了函数名称，返回类型和参数列表等信息，以便在程序中使用该函数。声明语法如下：

return_type function_name(parameter_list);

其中，return_type 是函数返回类型，function_name 是函数名称，parameter_list 是一个参数列表，其包含每个参数的数据类型和参数名称。

例如：

int add(int x, int y);

这是一个名为 add 的函数的声明，它接受两个 int 类型的参数并返回一个 int 类型的值。

"main" 函数是 C 语言中程序的入口，它是一个特殊的函数。每个 C 程序都有且仅有一个 main 函数。当程序开始执行时，程序的控制流就转移到 main 函数的第一条语句。在 main 函数的执行结束后，整个程序就结束了。

main 函数可以带参数，带返回值，但是习惯上都不带参数，并且返回值为整数，表示程序的状态。通常，0 表示正常结束，其他数字表示不同的错误状态。

main 函数的完整语法如下：

int main(int argc, char *argv[])
{
   ...
   return 0;
}

其中，argc 是一个整数，表示程序的参数个数，argv 是一个字符串数组，表示程序的参数列表。

递归函数是一种特殊的函数，它在内部调用自己，用于解决问题的某些情况。

递归函数包含两个部分：基础情况和递归情况。

基础情况是当函数不再需要递归调用自己时的情况，递归情况则是该函数继续递归调用自己的情况。

例如，我们可以使用递归函数来计算阶乘

#include <stdio.h>

int factorial(int n)
{
    if (n == 0)
        return 1;
    else
        return n * factorial(n - 1);
}

int main()
{
    int n = 5;
    int result = factorial(n);
    printf("%d\n", result);
    return 0;
}

这段代码中，如果输入的 n 为 0，则递归函数直接返回 1，表示阶乘的基础情况。如果不是，则函数递归调用自己，并返回当前的 n 乘上递归调用的结果。

进制是表示数的不同的计数方式。通常我们使用的十进制，其中每一位上的数字的取值范围是0-9，十进制的进位规则是在当前位达到最大值（9）时，向高一位进1，且当前位清零。除十进制外，还有其他常用的进制如二进制（0和1），八进制（0到7），十六进制（0到9和A到F）。在编程中，我们常使用十六进制表示内存地址等。

进制转换是指将一种进制的数转换成另一种进制的数。例如，把十进制的数转换成二进制的数。

在进制转换中，常用到的算法是除法和模运算，在转换过程中，首先将十进制数除以二，得到的商和余数组成的数就是二进制的数。然后，不断进行除法操作，得到的余数从下往上排列，就是最终的二进制。

例如，把十进制的10转换成二进制的数：

10 ÷ 2 = 5 余 0

5 ÷ 2 = 2 余 1

2 ÷ 2 = 1 余 0

1 ÷ 2 = 0 余 1

所以十进制的10在二进制中表示为1010。

二进制小数转换为十进制小数的方法是：首先，分离出二进制小数的整数部分和小数部分，然后将整数部分转换为十进制，将小数部分乘以2的相应次幂，最后将整数部分和小数部分相加即可。

例如：二进制小数101.101转换为十进制小数。

1.将整数部分101转换为十进制：1×2^2 + 0×2^1 + 1×2^0 = 5。

2.将小数部分0.101转换为十进制：1×2^(-1) + 0×2^(-2) + 1×2^(-3) = 0.5 + 0.25 = 0.75。

3.整数部分加小数部分：5 + 0.75 = 5.75。

所以二进制小数101.101转换为十进制小数为5.75。

在计算机中，数字的存储方式采用了二进制，因此，对于一个二进制数字来说，它的表示方法是很重要的。有三种方法可以表示二进制数：原码、反码和补码。

  1. 原码：原码就是一个数的绝对值的二进制表示，并且第一位代表数字的符号（0代表正数，1代表负数）。

  2. 反码：反码是一个数字的原码的按位取反，并且第一位仍然为数字的符号位。

  3. 补码：补码是一个数字的反码加1，补码是现在计算机系统中用来存储和计算数字的一种方法。

举个例子，假设一个二进制数字是100101，它的原码是100101，反码是011010，补码是011011。

  • 原码：就是最原始的二进制数字，无论是正数还是负数都可以表示为原码。
  • 反码：如果一个数字是正数，那么它的反码与原码相同；如果是负数，那么反码是将原码第一位改为1，并且将其余位中的0变成1，1变成0。
  • 补码：对于正数，它的补码与原码相同；对于负数，补码是在反码的基础上加1。

这些是二进制数字在计算机中的表示方法。

位运算符是用于操作二进制位的运算符，常见的位运

上一篇： C 语言教程 - Hello World！

下一篇： 人人都能理解的 C 语言入门教程

推荐阅读