【新手解答2】深入探索 C 语言：一些常见概念的解析

C语言的相关问题解答

• 写在最前面
• 问题1
• • 变量名是否有可能与变量重名？
  • • 变量名和变量的关系
    • 变量名与变量是否会"重名"
    • 举例说明
    • 结论
  • 变量则是一个地址不变，值时刻在变的"具体数字"
  • • 变量的地址和值
    • 变量名与数据类型
    • 具体化
    • 示例
    • 结论
• 问题2
• • 关于你给我的这段代码
  • • 说明
  • 关于重新申明
  • • [函数声明 vs 函数定义](#函数声明 vs 函数定义)
    • 为什么在头文件中声明，在源文件中定义？
    • 关于代码顺序
    • 总结
  • Include并不能引用源文件？
  • • [为什么通常不包含 `.c` 文件](#为什么通常不包含 .c 文件)
    • 正确的使用方法
    • 结论
• 问题3
• • 关于main的声明
  • • [关于 `main` 函数](#关于 main 函数)
    • [在源文件中定义 `main`](#在源文件中定义 main)
    • 关于函数的声明和定义
    • 声明的必要性
    • 结论
  • 延伸：申明和头文件
  • • 头文件和源文件的关系
    • 关于声明的位置
    • 结论
    • 自己尝试修改后的代码

写在最前面

一位粉丝私信交流，回想起了当初的我C语言一题写一下午的，而且很多概念糊糊的不清楚。借助这次机会，整理了相关 C 语言中最常见而关键的疑惑，并对概念进行解答。

本篇博客的前身：【新手解答1】深入探索 C 语言：一些常见概念的解析

如有不对的地方欢迎指出！好久没接触C了hh

问题1

变量名是否有可能与变量重名？

认真学习了第一部分，变量名是一个地址，而变量则是一个存储空间，那么，变量名是否有可能与变量重名？例如以下我定义一个变量为a：int a，那么，这个a是否也是变量a的变量名？（举手）

在编程中，变量名和变量实际上是指同一件事情，但从不同的角度来描述它。变量名是我们给内存中存储数据位置的标签或名称。当你声明一个变量，比如 int a;，a 就是这个变量的名称，它用于标识和访问存储在某个内存位置的数据。

变量名和变量的关系

• 变量名 ：这是程序员为变量指定的标识符。在上述例子中，a 是变量名。
• 变量：它指的是内存中的一个存储位置，这个位置保存了数据（在这个例子中，是一个整数类型的数据）。

变量名与变量是否会"重名"

在这个上下文中，所谓的"重名"是没有意义的，因为变量名和变量是指同一个概念的两个方面：

• 当我们说"变量 a"，我们指的是使用名字 a 标识的那块内存区域。
• 因此，变量名 a 和变量 a 实际上指的是同一件事：那块用于存储整数值的内存空间。

举例说明

当你写下 int a;：

• 你创建了一个类型为 int 的变量。
• 这个变量的名字是 a。
• 变量名 a 用于引用或访问这个变量存储的数据。

结论

综上 ，变量名 a 就是用来指代那块特定的内存空间，这块空间用于存放 int 类型的数据。变量名和变量本身是相互关联的，但它们是同一个实体的两个不同表述。

变量则是一个地址不变，值时刻在变的"具体数字"

变量名与数据类型：数据类型规定了一类数据的操作，表示和存储方法，而变量则是一个地址不变，值时刻在变的"具体数字"（我可以这样理解吗？这样的具体化）

你的理解是正确的方向，但需要一些微调和精确化：

变量的地址和值

1. 地址：变量确实有一个固定的内存地址。这个地址是分配给变量的内存位置的标识符，不会在变量的生命周期内改变。

2. 值：变量的值是存储在这个地址中的数据。这个值可以改变，即你可以在程序运行期间更新变量存储的数据。

变量名与数据类型

• 数据类型：数据类型定义了变量可以存储的数据的种类（例如整数、浮点数、字符等），以及在这些数据上可以进行的操作（例如加法、减法、比较等）。数据类型还决定了变量占用的内存大小。

• 变量名：变量名是你在代码中用来引用这个特定内存地址的标识符。当你在代码中使用变量名时，你实际上是在访问存储在那个内存地址中的数据。

具体化

你可以将变量视为数据类型的具体化表现：

• 数据类型提供了一个抽象的框架，说明了存储什么类型的数据以及可以执行哪些操作。
• 变量则是这个框架的具体实例，它具有一个固定的地址和可以变化的值。

示例

考虑以下 C 语言代码段：

int number;
number = 5;

• int 是数据类型，它规定 number 可以存储整数，并且定义了可以对 number 进行的操作，比如算术运算。
• number 是变量名，用于标识一个内存位置。
• 这个内存位置有一个固定的地址，在程序的运行期间不变。
• number 的值（在这个例子中是 5）可以改变。你可以在程序中将 number 的值改变为其他整数。

结论

综上 ，你的理解是正确的，只需注意变量的地址是固定的，而它的值是可以变化的。变量名是我们用来在代码中引用这个地址的标识符。

问题2

关于你给我的这段代码

a.c
#include" a.h"
int main()
{
    fun( );
}
void fun(void)
{
   printf("hello world\\n");
}

a.h
extern void fun(void);

你提供的代码片段已经相当接近标准的写法，但仍有一些改进的空间。下面是修改后的代码及其说明：

// a.h
extern void fun(void);

// a.c
#include "a.h"
#include <stdio.h> // 添加对标准输入输出库的引用

int main() {
    fun();
    return 0; // 明确返回值
}

void fun(void) {
    printf("hello world\n"); // 修正转义字符
}

说明

1. 头文件（a.h） ：extern void fun(void); 这行是正确的。它告诉编译器函数 fun 在其他地方定义，这是函数声明的标准写法。

2. 源文件（a.c）：

   • #include "a.h"：这是正确的，它包含了头文件 a.h，其中包含了 fun 函数的声明。
   • #include <stdio.h>：添加这个包含是因为代码使用了 printf 函数，这个函数定义在标准输入输出库 <stdio.h> 中。
   • int main()：主函数 main 应该返回一个整数值，通常在成功执行后返回 0。这是一个好的编程实践，符合大多数操作系统对主函数返回值的期望。
   • printf("hello world\n")：我修正了转义字符。原代码中的 \\n 会打印出 \n 字符串，而不是实际的换行。正确的写法是 \n，它代表换行。

这些修改将使代码更加标准化和符合普遍的 C 语言编程规范。

关于重新申明

又学习了一下第二段，又有了新的问题，a.h中原本就包含了fun（）函数的声明吧，那为什么在代码尾部又重新申明了一次呢，而且如果要声明，为什么不在include前面呢？（我一个朋友说，那段代码的格式有些许的不规范，所以导致我这种人看不懂......）

这个问题涉及到 C 语言中函数声明和定义的区别，以及它们在代码中的放置顺序。让我们澄清一下这些概念。

函数声明 vs 函数定义

在 C 语言中，函数声明 和函数定义是两个不同的概念：

1. 函数声明 告诉编译器函数的名称、返回类型以及参数（如果有的话）。它不提供函数的实际实现。例如，extern void fun(void); 是一个函数声明。

2. 函数定义提供了函数的实际实现。它包括函数的代码块，即函数体。例如：

   void fun(void) {
       printf("hello world\n");
   }

   这是函数 fun 的定义。

为什么在头文件中声明，在源文件中定义？

• 将函数声明放在头文件（如 a.h）中是为了让其他源文件（可能不止 a.c）也能知道这个函数的存在和它的接口。这样，任何 #include "a.h" 的文件都可以调用 fun 函数。

• 函数定义通常放在一个源文件（如 a.c）中，它提供了函数的具体实现。每个函数只应该在程序中有一个定义，这样编译器才能正确地编译程序。

关于代码顺序

• 通常，你先 #include 所需的所有头文件，然后再写函数定义。这是因为函数定义可能依赖于头文件中的声明。例如，如果你的函数使用了某个类型或宏定义，这些可能在头文件中声明。

• 在 a.c 文件中，函数 fun 的定义放在 main 函数之后是可以的。在 C 语言中，只要函数在使用前被声明，编译器就能识别它。这就是为什么我们在 a.h 中声明 fun，然后在 a.c 中包含 a.h。

总结

• 函数声明在头文件中：为了让其他文件知道函数的存在。
• 函数定义在源文件中：提供函数的实际代码。
• 先包含头文件，然后写代码：确保所有的声明在使用前都是可见的。

Include并不能引用源文件？

我是华生，我发现了盲点

上文中提到一个源文件，可以通过include包含多个头文件，而include又是引用的意思，那么说明Include并不能引用源文件，是这样的么？

你的观察是正确的。在 C 语言编程中，#include 指令通常用于包含头文件（.h 文件），而不是用来直接包含源文件（.c 文件）。让我们探讨一下原因和背后的逻辑：

为什么通常不包含 .c 文件

1. 避免重复定义 ：如果你在多个源文件中包含同一个 .c 文件，那么该 .c 文件中的函数和变量会在每个包含它的文件中重复定义。这会导致编译错误，因为 C 语言不允许多个相同的全局定义。

2. 编译器和链接器的工作方式 ：在 C 语言的编译过程中，每个 .c 文件通常被单独编译成一个对象文件（.o 或 .obj 文件）。然后，链接器将这些对象文件链接在一起，形成最终的可执行程序。如果一个 .c 文件被包含在另一个 .c 文件中，这会干扰正常的编译和链接过程。

3. 模块化和封装 ：使用头文件（.h 文件）是一种实现代码模块化和封装的方法。头文件提供了接口（即函数和变量的声明），而实现（即函数和变量的定义）则放在 .c 文件中。这种分离有助于代码的维护和重用。

正确的使用方法

• 头文件：用于声明函数、变量、宏定义和类型等。这些声明告诉编译器这些元素的存在和接口，但不提供具体实现。

• 源文件：包含具体的函数和变量定义。源文件可以包含头文件以使用在其中声明的元素。

结论

综上，是的，#include 指令通常不用于直接包含 .c 源文件。相反，它被用来包含头文件，这些头文件再被多个源文件共享，以提供必要的声明和接口。这是 C 语言中实现代码组织、模块化和重用的标准做法。

问题3

关于main的声明

声明是一种告知系统调用内容的信息，这内容包括定义函数和，对象

只有有了声明才能调用定义，但是main就已经是程序的起始点了，那么，假如我们所有的预设定的点c文件都没有main，而我们在编译器的第一行写下a.c，引用一个头文件之后，再直接定义Main，这样是可以的么？

我在网络上查到的资料说，声明可以声明定义，函数和对象，可是在一个头文件中，函数除了定义就是声明（目前接触到的是这样子的），难道声明还要再声明一遍吗？

你的问题涉及了几个重要的编程概念，包括函数的声明和定义，以及 main 函数在 C 程序中的特殊地位。我将逐一解释这些概念以帮助你理解。

关于 main 函数

main 函数在 C 语言程序中有特殊的地位，它是程序的入口点。编译器在编译程序时会寻找 main 函数，因为程序的执行是从 main 开始的。通常情况下，main 函数不需要在任何头文件中声明，因为编译器已经默认知道 main 函数的存在。

在源文件中定义 main

当你编写一个 C 程序时，至少需要有一个源文件包含 main 函数的定义。这个定义提供了程序执行的起点。例如：

// a.c
#include "someheader.h"

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

在这个例子中，main 函数直接定义在 a.c 文件中，这是完全有效和标准的做法。你不需要在任何地方再声明 main 函数。

关于函数的声明和定义

• 声明：函数的声明告诉编译器函数的名称、返回类型以及参数。声明不提供函数的具体实现。例如：

  // 在头文件中或者源文件中
  void myFunction(int param);

• 定义：函数的定义提供了函数的具体实现，即函数体。每个函数只能有一个定义。例如：

  // 在源文件中
  void myFunction(int param) {
      // 函数体
  }

声明的必要性

对于普通函数（非 main），如果你想在一个源文件中调用另一个源文件中定义的函数，你需要在调用它的源文件中提前声明这个函数。这通常通过包含一个包含了该函数声明的头文件来实现。对于 main 函数，由于它是程序的标准入口点，所以不需要额外的声明。

结论

• main 函数是程序的起始点，通常直接定义在一个源文件中，不需要额外声明。
• 对于其他函数，如果它们在不同的源文件中被调用，通常需要在头文件中声明，然后在源文件中定义。

延伸：申明和头文件

这里的把声明放进头文件中，究竟是头文件中原本就有（抱歉，我真的很笨，现在还有点分不清，现在才找好描述方式），还是原本就有，但是仍需要另起一行，进行声明呢？（我一会再优化一下语句，尽量把我想的乱的其他地方表现出来）
现在又想了一下，我觉得首先要弄清的是a点c后面跟的那一大段和a点h后面跟的那一小段是否是同一个文件内运作的？

你的问题涉及到头文件和源文件在 C 语言项目中的使用和组织方式。我将逐一解释，以帮助你更好地理解。

头文件和源文件的关系

在 C 语言中，头文件（.h 文件）和源文件（.c 文件）一起工作，但它们承担不同的角色：

1. 头文件（.h）：用于声明函数、全局变量、宏、类型等。这些声明告诉编译器这些元素的存在和它们的接口，但不提供具体实现。

2. 源文件（.c）：包含具体的函数定义和全局变量的实现。源文件可以包含一个或多个头文件，以便使用在头文件中声明的元素。

关于声明的位置

• 在头文件中声明 ：通常，函数在头文件中被声明，以便这些函数可以在多个源文件中使用。在你的例子中，fun 函数应该在其他地方（另一个 .c 文件）定义。

• 在源文件中定义：函数的具体实现（定义）放在源文件中。每个函数只能在一个地方定义一次。

结论

• 头文件中的声明不需要在源文件中重复声明。源文件通过 #include 指令使用头文件中的声明。

• 如果 fun 函数的定义在 a.c 文件中或其他 .c 文件中，那么程序就是完整的。

自己尝试修改后的代码

a.h
extern void fun();
a.c
#include "a.h"
int main(){
      fun();
}

这是我尝试自己......写的，不知道对不对？

因为我的理解是这样的：

a点c下面的那一大段是引用a点h里对函数声明的，然而，图中却把a点h的声明，放在了最后，那就意味着前面的a点h，里面并没有这个声明......？不知道该怎么理解

你提供的代码示例是正确的，并且很好地展示了头文件和源文件的常见用法。

在这个例子中：

• a.h 包含了函数 fun 的声明。extern 关键字是可选的，它在这里强调 fun 函数在别的地方（其他源文件）定义。

• a.c 包含了 main 函数的定义。它通过 #include "a.h" 指令包含了 a.h 头文件，因此 a.c 知道 fun 函数的存在和其接口。

---

希望这些解释能够帮助你更好地理解这些概念。如果还有疑问，欢迎继续提问！