526互联

C++ - extern关键字的用法

发布时间 2023-10-11 17:13:42作者: [BORUTO]
extern可以置于变量或者函数前,以标示变量或者函数的定义在别的文件中,提示编译器遇到此变量和函数时在其他模块中寻找其定义。此外extern也可用来进行链接指定
 

一、定义和声明的区别

声明用来告诉编译器变量的名称和类型，而不分配内存，不赋初值。

定义为了给变量分配内存，可以为变量赋初值。

注：定义要为变量分配内存空间；而声明不需要为变量分配内存空间。

extern int i; //声明，不是定义
int i; //声明，也是定义
注意事项：声明可以多次，定义只能一次。
 

二、extern用法

 

2.1 extern 变量

如果文件b.c需要引用a.c中变量int a，就可以在b.c中声明extern int a，然后就可以引用变量a。能够被其他模块以extern修饰符引用到的变量通常是全局变量。

注意，extern int a可以放在a.c中的任何地方，具体作用范围和局部变量相同。

extern的原理很简单，就是告诉编译器：“你现在编译的文件中，有一个标识符虽然没有在本文件中定义，但是它是在别的文件中定义的全局变量，你要放行！”

举例

（1）、test.h文件

/*extern*/
//声明外部变量
extern int a;
extern int b;

（2）、test.cpp文件

/*extern*/
#include "test.h"
 
//定义外部变量、外部变量初始化
int a = 520;
int b = 1314;

（3）、main.cpp文件

/*extern*/
//使用外部变量
#include <stdio.h>
#include "test.h"
/*#include"test.cpp"*/	//不可以这样引用，否则警告LNK2005、LNK1169
 
int main(void)
{
	printf("a = %d , b = %d\n", a, b);
 
	return 0;
}

运行结果： 

 

2.2 extern 函数

为什么要用extern 函数呢？直接#include相应的头文件不可以嘛？

例子，如a.cpp 想调用b.cpp中的delayms函数,有两种方法：

  • 方法1：include 头文件，即直接 #include "delayms.h"
  • 方法2：extern 方法 ，extern void delayms()这句在调用文件中使用，表示引用全局函数delayms()。

优点：a.cpp不采用方法一，就不会包含inlcude "delayms.h"，就不会引入大量头文件，进而不会引入大量的无关函数。这样做的一个明显的好处是，会加速程序的编译（确切的说是预处理）的过程，节省时间。

函数的声明extern关键词是可有可无的，因为函数本身不加修饰的话就是extern。

但是引用的时候一样需要声明的。

甚至在声明时，连函数形参名都可以省略

//注意:函数的声明语句中，关键字extern可以省略
//函数形参名可以省略，只关注变量类型
//extern int add(int a, int b);
//int add(int a, int b);
int add(int , int );

下面三条语句等效

extern int add(int a, int b);

int add(int a, int b);

int add(int , int );

举例

（1）、other.cpp文件

// other.cpp
//extern 使用 
//全局变量
/*  注意事项：使用extern时，全局变量的声明不能加初始值*/
//声明 declaration
//extern int a;
//extern double b;
//extern float numbers[5];
//定义 definition
extern int a = 1;
double b = 5;
float numbers[5] = { 1,0,20,30 };
double get_area(double r)
{
	return 3.14*r*r;
}
int add(int a, int b)
{
	return a + b;
}

（2）、main.cpp文件

#include<iostream>
using namespace std;

extern double get_area(double r);//函数声明
extern int a;

//注意:函数的声明语句中，关键字extern可以省略
//函数形参名可以省略，只关注变量类型
//extern int add(int a, int b);
//int add(int a, int b);

int add(int, int);

int main()
{
	double r;
	cout << "enter r:";
	cin >> r;
	double area = get_area(r);
	cout << "result=" << area << endl;
	cout << "other.cpp里面的全局变量 a= " << a << endl;
	a = 1000;
	cout << "other.cpp里面的全局变量 a= " << a << endl;
	cout << "两数之和" << add(0, 102) << endl;
	return 0;
}
//使用extern注意事项：
//被声明为extern 的函数或者全局变量，其实在本cpp中也可以定义
// extern 的作用：告诉编译器，在某个cpp文件中，存在这么一个函数或者全局变量
//所以在本cpp其实也是可以定义的

调试结果：

 

2.3 extern 类

使用extern 定义全局类对象

log.h

#pragma once

class Log
{
public:
	enum Type
	{
		Info,
		Warning,
		Error,
		Failed,
		typeSize
	};
	Log();
	~Log();
	void Output(Type type, const char* string);

private:
};

log.cpp

#include "log.h"
#include <iostream>
using namespace std;

Log::Log()
{
	cout << "test" << endl;
}

Log::~Log()
{
}

void Log::Output(Type type, const char* string)
{
	cout << "string: " << string << endl;
}

global_info.h

#pragma once
#include "log.h"

extern Log* g_pLog;

extern int GetSkin();

global_info.cpp

#include "global_info.h"

Log* g_pLog = nullptr;

int GetSkin()
{
	int iIndex = 0;
	return iIndex;
}

 test.h

#pragma once
#include "global_info.h"

class Test
{
public:
	Test();
	~Test();

private:

};

test.cpp

#include "test.h"
#include <iostream>
using namespace std;

Test::Test()
{
	g_pLog->Output(Log::Info, "测试一下！");

	int skintype = GetSkin();
	cout << "skintype = " << skintype<<endl;
}

Test::~Test()
{
}

main.cpp

#include <stdio.h>
#include <iostream>
#include "global_info.h"
#include "test.h"

using namespace std;


int main()
{
    //构建对象
    char LogPath[255]  = "C:\\Users\\Administrator\\AppData\\Roaming\\Log\\log.txt";
    g_pLog = new Log();

    g_pLog->Output(Log::Info, "你好");
    Test* t1 = new Test();

    return 0;
}

运行结果：

 

 

2.4 在C＋＋文件中调用C方式编译的函数

比如在C＋＋中调用C库函数，就需要在C＋＋程序中用 extern “C” 声明要引用的函数。这是给链接器用的，告诉链接器在链接的时候用C函数规范来链接。主要原因是C＋＋和C程序编译完成后在目标代码中命名规则不同。

示例代码

1. 处理被调用的C头文件

 my_module.h文件

#pragma once
#include<stdio.h>
 
#ifdef __cplusplus
extern "C"{
#endif
 
	void func1();
	int func2(int a,int b);
 
#ifdef __cplusplus
}
#endif

my_module.c文件

#include "my_module.h"
 
void func1() {
  printf("hello world.");
}
int func2(int a, int b) {
  return a+b;
}

main.cpp文件

#include "my_module.h"
#include<iostream>
using namespace std;
 
int main()
{
  func1();
  cout << func2(10, 20) << endl;
}
 
注意：.c文件和.cpp不能混在一起编译，要分别编译成目标文件.o，再进行链接生成可执行程序
 
 
2. 处理调用的c++文件
my_module.h文件
#pragma once
#include <stdio.h>
 
void func1();
int func2(int a, int b);

my_module.c文件

#include "my_module.h"
 
void func1() {
  printf("hello world.");
}
int func2(int a, int b) {
  return a+b;
}

main.cpp文件

#include <iostream>
using namespace std;
 
extern "C" {
#include "my_module.h"
}
 
int main()
{
  func1();
  cout << func2(1, 2) << endl;
}

 

三、通俗讲解extern

在定义变量的时候，这个extern可以被省略(定义时，默认均省略)；

在声明变量的时候，这个extern必须添加在变量前，所以有时会让你搞不清楚到底是声明还是定义。

或者说，变量前有extern不一定就是声明（首先声明必须要有extern，但是定义也可以不省略extern,编译器也没报错,但是尽量不要采用这种定义方式）， 而变量前无extern就只能是定义（因为声明必须要有extern，没有extern只能是定义省略extern的情况）！！！

一般来讲，定义默认省略extern，判断有extern int a;这种格式的语句即为声明

注意事项：无论是否有extern修饰，赋初值==定义。如下两种方式是等价的，必为定义！！！

//如果在声明的时候给变量赋值，那么就去掉extern直接定义变量赋值是等价的
extern int a = 10;//尽量不要写这种定义方式
int a = 10;//上述两条语句等价
 
总结：
1. 要养成正规的编程习惯，变量、函数、结构体、类的声明要放在.h文件中，比如test.h；结构体和类体的实现可以放在test.h文件中，但不要初始化。声明外部变量、声明外部函数，等时必须使用extern关键字。
2. 把变量的初始化、函数方法的实现、结构体的实现、类体的实现放在另一个.cpp文件中，这个.cpp文件默认的要与.h文件同名，比如test.cpp。同时在test.cpp要引用test.h文件。声明外部变量、声明外部函数时必须使用extern关键字。初始化外部变量、定义外部函数，等的实现方法时不要重复使用extern关键字。
3. main.cpp负责变量的引用、函数的调用、结构体变量定义和结构体成员的调用，类对象的定义和类成员的调用；调用外部变量、外部函数时不需要使用extern关键字。main.cpp要引用test.h文件，一定不要引用test.cpp文件。