VC++中全局变量定义的问题(转)

合集下载

c语言全局变量和局部变量问题及解决汇总

c语⾔全局变量和局部变量问题及解决汇总答：能，局部会屏蔽全局。

要⽤全局变量，需要使⽤"::"局部变量可以与全局变量同名，在函数内引⽤这个变量时，会⽤到同名的局部变量，⽽不会⽤到全局变量。

对于有些编译器⽽⾔，在同⼀个函数内可以定义多个同名的局部变量，⽐如在两个循环体内都定义⼀个同名的局部变量，⽽那个局部变量的作⽤域就在那个循环体内。

答：extern可以⽤引⽤头⽂件的⽅式，也可以⽤extern关键字，如果⽤引⽤头⽂件⽅式来引⽤某个在头⽂件中声明的全局变理，假定你将那个变写错了，那么在编译期间会报错，如果你⽤extern⽅式引⽤时，假定你犯了同样的错误，那么在编译期间不会报错，⽽在连接期间报错。

答：可以，在不同的C⽂件中以static形式来声明同名全局变量。

可以在不同的C⽂件中声明同名的全局变量，前提是其中只能有⼀个C⽂件中对此变量赋初值，此时连接不会出错static局部变量和普通局部变量有什么区别？static函数与普通函数有什么区别？全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。

全局变量本⾝就是静态存储⽅式，静态全局变量当然也是静态存储⽅式。

这两者在存储⽅式上并⽆不同。

这两者的区别虽在于⾮静态全局变量的作⽤域是整个源程序，当⼀个源程序由多个源⽂件组成时，⾮静态的全局变量在各个源⽂件中都是有效的。

⽽静态全局变量则限制了其作⽤域，即只在定义该变量的源⽂件内有效，在同⼀源程序的其它源⽂件中不能使⽤它。

由于静态全局变量的作⽤域局限于⼀个源⽂件内，只能为该源⽂件内的函数公⽤，因此可以避免在其它源⽂件中引起错误。

从以上分析可以看出，把局部变量改变为静态变量后是改变了它的存储⽅式即改变了它的⽣存期。

把全局变量改变为静态变量后是改变了它的作⽤域，限制了它的使⽤范围。

static函数与普通函数作⽤域不同，仅在本⽂件。

只在当前源⽂件中使⽤的函数应该说明为内部函数(static)，内部函数应该在当前源⽂件中说明和定义。

CC++语言中全局变量重复定义问题的解决方法

CC++语⾔中全局变量重复定义问题的解决⽅法前⾔在C语⾔中使⽤extern 关键字来定义全局变量的时候，我们需要在.h⽂件和.c⽂件中重复定义，这种重复，导致了出错⼏率的增加。

今天，在整理⾃⼰的代码的时候，考虑到我写的代码从⼀⾄终都是在⼀个cpp⽂件⾥⾯。

于是，想把⾃⼰的代码中的各个模块分离开来，以便更好地阅读和管理。

遇到的问题我的做法是：宏定义、结构体定义、函数声明以及全局变量定义放到⼀个head.h头⽂件中函数的定义放到head.cpp中main函数放到main.cpp中然⽽却报错了，提⽰xxx变量在*.obj⽂件中已定义问题出现的原因为什么会出现这种情况呢？⾸先单个⽂件的编译是独⽴的。

在head.cpp编译到head.obj，main.cpp编译到main.obj。

这个过程没有报错，也就是说明编译过程是没有问题的。

接下来是obj的链接。

在链接main.obj与head.obj的时候，此时编译器发现head.obj为这些全局变量分配了内存空间，⽽在main.obj中也为这些全局变量分配了内存空间。

同样⼀个变量却出现了两个不同的内存地址。

于是编译器报错。

不是办法的办法把head.h⾥⾯的头⽂件的全局变量都加上static。

编译便可通过，可是却会不经意出现了其他问题。

static只是把变量的⽣存周期延长，同时也把该变量限定于当前的⽂件。

⽽之所以能⽤于main.cpp中，是因为在编译的时候复制了⼀个变量名相同的变量给main.cpp⽽已。

那么main.cpp⾥⾯的“全局变量”的改变，并不能改变原来head.h⾥⾯的全局变量的值。

这样⼦虽然编译通过了，但是程序是错误的。

真正的解决⽅法把全局变量定义放到head.cpp⽂件中。

在head.h存放全局变量的声明，同时每个声明前⽤ extern 去修饰。

我的个⼈想法我觉得为了能更加分离全局变量，可以做的⼀个做法是：全局变量定义依旧放在head.cpp中。

新建⼀个global.h的头⽂件，存放全局变量的声明，同时每个声明前⽤ extern 去修饰。

C语言全局变量定义方法

C语言全局变量定义方法在C语言中，全局变量是在函数外部定义的变量，它可以被整个程序的各个函数访问和使用。

全局变量的作用范围是整个程序，在程序中任何地方都可以使用。

全局变量的定义方式有以下几种：1.在函数外部定义全局变量：```int globalVar; // 声明一个全局变量```这种方法将全局变量的定义放在所有函数的外部，可以在程序中的任何位置对其进行访问和使用。

全局变量在没有被初始化时，默认值为0。

2.在函数外部定义全局变量并初始化：```int globalVar = 100; // 声明并初始化一个全局变量```这种方法在定义全局变量的同时可以进行赋值初始化，全局变量的初始值可以根据需要自行设定。

3.在头文件中定义全局变量：除了在函数外部定义全局变量之外，还可以创建一个头文件，然后在需要使用全局变量的源文件中包含这个头文件，即可实现全局变量的共享。

在头文件中定义全局变量的步骤如下：a. 在一个头文件（例如global.h）中声明全局变量：```extern int globalVar; // 声明一个全局变量```注意使用`extern`关键字来修饰全局变量，表示该变量的定义在其他源文件中。

b.在需要使用全局变量的源文件中包含头文件：```#include "global.h"```通过包含头文件，就可以在源文件中访问和使用全局变量。

4. 使用static关键字定义全局变量：通过使用`static`关键字可以定义静态全局变量，静态全局变量的作用范围也是整个程序，但其作用范围被限制在定义它的源文件中。

静态全局变量的定义和普通全局变量的定义类似，只需要在声明时加上static 关键字即可：```static int globalVar; // 声明一个静态全局变量```静态全局变量只能在定义它的源文件中使用，其他源文件无法访问和使用。

需要注意的是，全局变量的使用应尽量减少，并且在使用时要小心。

关于c++中的全局变量（不赋值的全局变量算定义）

关于c++中的全局变量（不赋值的全局变量算定义）定义有三种：1.不赋值的定义：int a;2.赋值的定义：int a=5; 或者 int a;a=5;3.加extern的定义：extern int a=5;//其实和不加是⼀样的。

声明只有⼀种：extern int a;所有，不要再问我变量不赋值算不算定义，告诉你，算，你要是敢包含两次不赋值的变量的头⽂件两次，编译器就敢报错，重定义c++单定义语法规则：变量只能定义⼀次。

定义与声明的区别：定义：声明⼀个变量，且为它分配内存空间。

声明：只声明⼀个变量，并不为它分配内存空间。

因此定义变量的过程已经声明了这个变量。

定义变量的⽅法：int a;//定义⼀个变量a，并且分配了内存空间，值为0（虽然没有显⽰为变量a提供值，但是编译器已经为a分配了内存空间，且赋值为0）int a=5;//定义变量a,并赋值为5（显⽰的赋值为5）extern int a=5;//虽然加上了extern关键字，但是由于显⽰的赋值了，所以仍然是定义。

那如何只声明变量呢？extern int a;//extern关键字表⽰变量a已经在别处定义了，这⾥需要使⽤，就声明⼀下。

这也是说要使⽤全局变量，必须要提前声明⼀下。

因此全局变量使⽤规则为：1.在define.cpp⽂件中定义变量//define.cpp[extern] int a=3;//在⽂件define.h中定义⼀个全局变量a，赋值为3.（extern关键字可以有，也可以没有）2.在define.h⽂件中声明变量extern int a;3.在⽤户⽂件中引⽤变量//user.h⽅法⼀：#include "define.h" //包含⽤extern声明的全局变量的⽂件（因为已经声明了，这⾥包含⼀下就可以了）或者⽤extern关键字声明⽅法⼆：extern int a; //2.必须声明已经定义了的变量a，这⾥没有给a分配内存，⽽是对外部定义好的a的引⽤；4.使⽤全局变量a+=1; //3.使⽤全局变量。

alreadydefinedin.obj“符号已定义”问题原理及解决方案

already defined in *.obj 符“号已定义”问题原理及解决方案VC6 如果想在 stdafx.h 中定义全局变量，由于该头文件会被include 多次，所以，经常会出现以下经典的错误：already defined in StdAfx.obj 。

解决方法：把该变量的定义int g_flag 放到 stdafx.cpp 中，然后在使用的地方extern 一下。

假如你在CAADlg.cpp 中使用了该变量g_flag ，那么就在CAADlg.cpp 的首部，构造函数的定义之外，添加上extern int g_flag;许多 Visual C++ 的使用者都碰到过LNK2005:symbol already defined 和LNK1169:one or more multiply defined symbols found 这样的链接错误，而且通常是在使用第三方库时遇到的。

对于这个问题，有的朋友可能不知其然，而有的朋友可能知其然却不知其所以然，那么本文就试图为大家彻底解开关于它的种种疑惑。

大家都知道，从C/C++ 源程序到可执行文件要经历两个阶段:(1)编译器将源文件编译成汇编代码，然后由汇编器 (assembler) 翻译成机器指令 (再加上其它相关信息 )后输出到一个个目标文件(object file,VC 的编译器编译出的目标文件默认的后缀名是 .obj) 中；(2) 链接器 (linker) 将一个个的目标文件 (或许还会有若干程序库 )链接在一起生成一个完整的可执行文件。

编译器编译源文件时会把源文件的全局符号(global symbol) 分成强 (strong) 和弱 (weak) 两类传给汇编器，而随后汇编器则将强弱信息编码并保存在目标文件的符号表中。

那么何谓强弱呢？编译器认为函数与初始化了的全局变量都是强符号，而未初始化的全局变量则成了弱符号。

比如有这么个源文件:extern int errorno;int buf[2] = {1,2};int *p;int main(){return 0;}其中 main 、 buf 是强符号， p 是弱符号，而 errorno 则非强非弱，因为它只是个外部变量的使用声明。

c++定义全局变量详解

c++定义全局变量详解在C++中定义全局变量是应该尽量在.cpp⽂件中定义，⽽不要在.h ⽂件中定义，定义好了之后，可以在.h⽂件中利⽤extern关键字进⾏声明。

如果在.h⽂件中定义的话，多层包含可能会引起重复定义的错误。

下⾯是⼀个⽰例：在g_bash.cpp中定义全局变量：// g_bash.cpp#include "g_base.h"int g_TicketCount = 0; // 定义全局变量并初始化在g_bash.h⽂件中利⽤extern关键字进⾏声明：// g_bash.h#ifndef G_BASE_H#define G_BASE_Hextern int g_TicketCount; // 全局变量声明#endif // G_BASE_H然后在其他⽂件要使⽤这些变量的时候，只要#include "g_base.h"就可以了，⽽且不会引起重复定义的错误。

main.cpp下引⽤⽰例：#include <QCoreApplication>#include <iostream>#include g_base.husing namespace std;void proc(){cout<< proc(): <<endl;g_TicketCount++;}int main(int argc, char *argv[]){QCoreApplication a(argc, argv);cout<< g_TicketCount = << g_TicketCount << endl;proc();cout<< g_TicketCount = << g_TicketCount << endl;return a.exec();}结果：总结本篇⽂章就到这⾥了，希望能够给你带来帮助，也希望您能够多多关注的更多内容!。

C语言在头文件中定义全局变量

头文件定义全局变量等问题全局变量可不可以定义在可被多个.C文件包含的头文件中？为什么？可以，在不同的C文件中以static形式来声明同名全局变量。

头文件中不可以直接定义变量和函数，但是可以定义static变量，类。

extern 用法，全局变量与头文件（重复定义）用#include可以包含其他头文件中变量、函数的声明，为什么还要extern关键字,如果我想引用一个全局变量或函数a，我只要直接在源文件中包含#include<xxx.h> (xxx.h包含了a的声明)不就可以了么，为什么还要用extern 呢？？这个问题一直也是似是而非的困扰着我许多年了，今天上网狠狠查了一下总算小有所获了：头文件首先说下头文件，其实头文件对计算机而言没什么作用，她只是在预编译时在#include的地方展开一下，没别的意义了，其实头文件主要是给别人看的。

我做过一个实验，将头文件的后缀改成xxx.txt，然后在引用该头文件的地方用#include"xxx.txt"编译，链接都很顺利的过去了，由此可知，头文件仅仅为阅读代码作用，没其他的作用了！不管是C还是C++，你把你的函数，变量或者结构体，类啥的放在你的.c或者.cpp 文件里。

然后编译成lib,dll,obj,.o等等，然后别人用的时候最基本的gcc hisfile.cpp yourfile.o|obj|dll|lib 等等。

但对于我们程序员而言，他们怎么知道你的lib,dll...里面到底有什么东西？要看你的头文件。

你的头文件就是对用户的说明。

函数，参数，各种各样的接口的说明。

那既然是说明，那么头文件里面放的自然就是关于函数，变量，类的“声明”了。

记着，是“声明”，不是“定义”。

那么，我假设大家知道声明和定义的区别。

所以，最好不要傻嘻嘻的在头文件里定义什么东西。

比如全局变量： #ifndef _XX_头文件.H#define _XX_头文件.H int A; #endif 那么，很糟糕的是，这里的int A是个全局变量的定义，所以如果这个头文件被多次引用的话，你的A会被重复定义显然语法上错了。

c语音中全局变量的名词解释

c语音中全局变量的名词解释C语言中全局变量的名词解释在C语言中，全局变量是指在程序的各个函数之外定义的变量。

它拥有全局的作用域，因此可以在程序的任何地方使用。

全局变量与局部变量相对，局部变量只能在其所属的函数内部使用。

全局变量具有以下特点：1. 可访问性：全局变量可以被程序中的任何函数访问和修改。

这意味着它可以在不同的函数中共享数据，方便数据的传递和共享。

2. 生命周期：全局变量在程序开始执行时被创建，在程序结束时才被销毁。

这意味着全局变量的生存周期与整个程序的生命周期一致，可以在程序的不同阶段保持数据的持久性。

3. 默认初始化：全局变量在定义时会被默认初始化。

根据类型的不同，全局变量的默认初始值可以是0、NULL或空字符串等。

全局变量的定义方式如下：```type variable_name;```其中，type表示变量的类型，variable_name表示变量的名称。

全局变量的定义通常会放在函数之外，以便于所有函数都能访问。

举例来说，我们可以定义一个全局变量来保存程序的执行次数：```c#include <stdio.h>int execution_count; // 全局变量void increment_execution_count() {execution_count++; // 在函数中使用全局变量}int main() {execution_count = 0; // 初始化全局变量increment_execution_count();printf("程序已执行 %d 次\n", execution_count);return 0;}```在上面的例子中，我们定义了一个整型的全局变量`execution_count`，并在`increment_execution_count()`函数中对其进行累加操作。

在`main()`函数中，我们将全局变量初始化为0，然后调用`increment_execution_count()`函数对其进行累加，并最终将结果打印出来。

c语言头文件中定义全局变量的问题

c语⾔头⽂件中定义全局变量的问题问题是这么开始的：最近在看⼀个PHP的扩展源码，编译的时候的遇到⼀个问题：ld: 1 duplicate symbol for architecture x86_64仔细看了⼀下源码，发现在头⽂件中出现了全局变量的定义。

简化⼀下后，可以这么理解：// t1.h#ifndef T1_H#define T1_Hint a = 0;#endif//------------------//t1.c#include "t1.h"#include "t2.h"int main(){return 0;}//-----------------//t2.h#include "t1.h"//empty//----------------//t2.c#include "t2.h"//empty//-------这两个c⽂件能否通过编译？想必有点经验的必会说不会，重定义了。

那么是否真的如此？并不这么简单。

第⼀个问题，#ifndef 的这个宏是否防⽌了重定义（redefinition）？答案：是。

但是是在单个translation unit中（wiki ）。

#ifndef 的头⽂件宏称为 include guards的（）我们知道，⼀个完整的编译的过程是经过one.c --> PREPROCESSOR -> tmp.c(temporary) -> COMPILER -> one.obj -> LINKER -> one.exe这三个过程的，⽽在预编译阶段，便会把include的⽂件展开，我们使⽤cc -E 命令来查看t1.c的预编译的结果：➜ t cc -E t1.c# 1 "t1.c"# 1 "<built-in>" 1# 1 "<built-in>" 3# 321 "<built-in>" 3# 1 "<command line>" 1# 1 "<built-in>" 2# 1 "t1.c" 2# 1 "./t1.h" 1int a = 0;# 3 "t1.c" 2# 1 "./t2.h" 1# 4 "t1.c" 2int main(void){return 0;}看到编译器把 t1.h 做了展开，我们看到了 a的定义。

c语言中实现全局变量

c语⾔中实现全局变量在⽤C语⾔编写程序的时候，我们常常想定义⼀个可以在不同.c⽂件中被使⽤的变量，以此来实现数据的传递。

但是这个变量定义的不对的话，就会在编译时出现编译错误，或者可以编译通过，但是没有实现变量在不同.c⽂件中实现共⽤。

正确的全局变量定义⽅式是这样的。

我们举例说明，项⽬⽂件夹project下有main.c、common.c和common.h三个⽂件，其中common.h⽂件分别#include在main.c和common.c ⽂件中。

现在希望声明⼀个字符型变量key，在main.c和common.c中公⽤。

使⽤extern关键字来声明变量为外部变量。

具体说就是在其中⼀个c⽂件中定义⼀个全局变量key，然后在另⼀个要使⽤key这个变量的c⽂件中使⽤extern关键字声明⼀次，说明这个变量为外部变量，是在其他的c⽂件中定义的全局变量。

请注意我这⾥的⽤词：定义和声明。

例如在main.c⽂件中定义变量key，在common.c⽂件中声明key变量为外部变量，这样这两个⽂件中就能共享这个变量key了。

（1）main.c⽂件　#include "common.h" unsigned char key; （2）common.c⽂件：　#include "common.h" extern unsigned char key;其实就是变量定义和变量声明的区别，变量定义使⽤“数据类型+变量名称”的形式，编译器需要给他分配内存单元的；⽽变量声明使⽤“extern 变量类型+变量名称”的形式，是告诉编译器我这个变量将在其他外部c⽂件中定义，我这⾥只是在外部⽤它。

编译器就不给他分配内存空间，⽽等到真正遇到变量定义的时候再给他分配内存空间。

1、普通变量定义成全局变量如果是普通类型，完全可以不⽤*.h⽂件，直接在*.c⽂件中定义，在调⽤⽂件处⽤extern 声明，因为对于普通类型，编译器是可以识别的。

C语言头文件，全局变量的定义和声明

让我们的思绪乘着时间机器回到大学一年级。

C原来老师正在讲台上讲着我们的第一个C 语言程序: Hello world!文件名First.cmain(){printf(“Hello world!”);}例程-1看看上面的程序，没有.h文件。

是的，就是没有，世界上的万物都是经历从没有到有的过程的，我们对.h的认识，我想也需要从这个步骤开始。

这时确实不需要.h文件，因为这个程序太简单了，根本就不需要。

printStr(){printf(“Hello world!”);}main(){printStr()}例程-2还是没有, 那就让我们把这个程序再稍微改动一下.文件名First.cmain(){printStr()}printStr(){printf(“Hello world!”);}例程-3等等，不就是改变了个顺序嘛, 但结果确是十分不同的. 让我们编译一下例程-2和例程-3,你会发现例程-3是编译不过的.这时需要我们来认识一下另一个C语言中的概念:作用域.我们在这里只讲述与.h文件相关的顶层作用域, 顶层作用域就是从声明点延伸到源程序文本结束, 就printStr()这个函数来说，他没有单独的声明,只有定义,那么就从他定义的行开始,到first.c文件结束, 也就是说,在在例程-2的main()函数的引用点上,已经是他的作用域. 例程-3的main()函数的引用点上，还不是他的作用域,所以会编译出错. 这种情况怎么办呢? 有两种方法,一个就是让我们回到例程-2, 顺序对我们来说没什么, 谁先谁后不一样呢，只要能编译通过,程序能运行, 就让main()文件总是放到最后吧. 那就让我们来看另一个例程,让我们看看这个方法是不是在任何时候都会起作用.文件名First.cplay2(){……………….………………..}play1(){……………..play2();……………………}main(){play1();}例程-4也许大部分都会看出来了，这就是经常用到的一种算法, 函数嵌套, 那么让我们看看, play1和play2这两个函数哪个放到前面呢?这时就需要我们来使用第二种方法,使用声明.文件名First.cplay1();play2();play2(){……………….play1();………………..}play1(){…………………….play2();……………………}main(){play1();}例程-4经历了我的半天的唠叨, 加上四个例程的说明,我们终于开始了用量变引起的质变, 这篇文章的主题.h文件快要出现了。

c语言全局变量的定义

c语言全局变量的定义
C语言全局变量的定义
C语言是当今编程语言中使用最广泛的一种。

由于其易学易用的特点，它受到了越来越多的开发者的青睐。

C语言中的全局变量是指在程序的任何地方都可以访问的变量。

它们可以通过关键字extern来定义，并且可以被多个文件所使用。

C语言全局变量的定义非常简单，只需要在变量前添加关键字extern，然后就可以在其他文件中使用它们了。

例如，如果在文件A 中定义了一个全局变量int x，只需要在文件B中添加extern int x;即可使用该变量。

C语言全局变量在实际开发过程中非常有用，它可以在多个文件之间共享信息，并且可以实现代码的复用。

但是，在使用全局变量时也要注意它们的作用域，因为它们可以被任意的文件访问，所以有可能会导致程序出现意外的错误。

C语言中的全局变量也不能定义在函数里，否则也会导致程序出现不可预料的错误。

C语言全局变量是一种非常有用的变量，它可以在多个文件中共享信息以实现代码的复用。

但是，在使用它们的时候，要注意它们的作用域，避免出现意外的错误。

VC全局变量的定义

全局变量一般这样定义：1。

在一类的.cpp中定义 int myInt;然后再在要用到的地方的.cpp里extern int myInt；这样就可以用了。

2。

在stdafx.cpp中加入:int myInt;然后在stdafx.h中加入:extern int myInt这样定义以后无论在什么文件中都是可见的.3。

比较规范的是，先定义一个Glbs.h，把所有的全局变量原始定义放进去。

然后定义一个Externs.h，把你先前定义在Glbs.h中的变量都加上extern。

注意：如果你在Glbs.h中设置了初值，那么在Externs.h中就不要加值了。

然后调用时，第一次调用的＃i nclude <Glbs.h>，以后调用的＃i nclude <Externs.h>另：问：如何在VC++中使用全局变量，以使文档中的所有类都能访问。

答：把该变量放到该应用程序类的头文件中的attribute处。

然后，在程序的任何地方，你都可以用下面的方法来访问该变量：CMyApp *app=（CMyApp*）AfxGet-App（）；app->MyGlobalVariable=…用这个方法，不但可以定义全局变量，也可以定义全局对象。

例如：MyClass MyObject；CMyApp*app=（CMyApp*）AfxGet-App（）；app->MyObject.MyFunction（）；VC中使用全局变量的2种办法及防错措施1. 对于全局变量存在和函数一样的问题，为了在其他CPP文件中能够访问这些变量，必须在主文件的H文件中加上extern声明，格式如下：extern varibletype var; （声明）在主文件的CPP文件中定义varibletype var; （定义）例子:AppWizard建立一个Test工程那么在Test.h中声明extern CString cs;在Test.app定义CString cs;如果要定义整个工程的全局变量，在任何一个CPP文件中进行定义，然后在需要引用这个变量的文件中进行声明。

C++全局变量的声明和定义

C++全局变量的声明和定义C++全局变量的声明和定义（1）编译单元（模块）在VC或VS上编写完代码，点击编译按钮准备⽣成exe⽂件时，编译器做了两步⼯作：第⼀步，将每个.cpp(.c)和相应的.h⽂件编译成obj⽂件；第⼆步，将⼯程中所有的obj⽂件进⾏LINK，⽣成最终.exe⽂件。

那么，错误可能在两个地⽅产⽣：⼀个，编译时的错误，这个主要是语法错误；⼀个，链接时的错误，主要是重复定义变量等。

编译单元指在编译阶段⽣成的每个obj⽂件。

⼀个obj⽂件就是⼀个编译单元。

⼀个.cpp(.c)和它相应的.h⽂件共同组成了⼀个编译单元。

⼀个⼯程由很多编译单元组成，每个obj⽂件⾥包含了变量存储的相对地址等。

（2）声明与定义函数或变量在声明时，并没有给它实际的物理内存空间，它有时候可保证你的程序编译通过；函数或变量在定义时，它就在内存中有了实际的物理空间。

如果你在编译单元中引⽤的外部变量没有在整个⼯程中任何⼀个地⽅定义的话，那么即使它在编译时可以通过，在连接时也会报错，因为程序在内存中找不到这个变量。

函数或变量可以声明多次，但定义只能有⼀次。

（3） extern作⽤作⽤⼀：当它与"C"⼀起连⽤时，如extern "C" void fun(int a, int b);，则编译器在编译fun这个函数名时按C的规则去翻译相应的函数名⽽不是C++的。

作⽤⼆：当它不与"C"在⼀起修饰变量或函数时，如在头⽂件中，extern int g_nNum;，它的作⽤就是声明函数或变量的作⽤范围的关键字，其声明的函数和变量可以在本编译单元或其他编译单元中使⽤。

即B编译单元要引⽤A编译单元中定义的全局变量或函数时，B编译单元只要包含A编译单元的头⽂件即可，在编译阶段，B编译单元虽然找不到该函数或变量，但它不会报错，它会在链接时从A编译单元⽣成的⽬标代码中找到此函数。

全局变量的声明与定义

全局变量的声明与定义
全局位置的注意点，就是在全局的位置是不能够写⼀些执⾏语句的，只能写⼀些全局变量的定义，并且初始化的话也只能⽤常量进⾏初始化。

int e=1；这就可以，所以在全局的这个位置，只能⽤常量进⾏初始化。

对于指针也⼀样，不要 int * p=(int *)malloc(4); 不可以，⽤⼀个变量都不可以，何况⽤⼀个函数。

另外，想在全局变量的位置执⾏⼀个printf，打印⼀个 printf（"asd"）; 能不能打印谁调⽤的它？？
所以，全局变量的位置》》》除了包含头⽂件这些预处理指令之外，这块能够写的东西就是全局变量，⽽且不要⽤变量初始化，也不能⽤函数初始化，只能⽤常量给全局变量初始化，另外全局的位置是不能写执⾏语句的，这块只认声明和变量的定义。

接下来看全局变量的⽣命周期：
与程序共存亡。

int e 是在程序加载的时候分配的空间，在程序正式运⾏之前（在主函数main调⽤之前）分配的空间。

当执⾏到int a的时候，上⾯的这些东西都已经分配好了。

结束时关闭程序/关闭软件，才会被释放掉。

接下来说作⽤域：
因为是全局变量，全局就是整个项⽬，所有的⽂件都认识这个 e。

既然声明可以出现多个（int e；），那么⼀般的把全局变量的声明放在头⽂件⾥⾯，其他的⽂件⼀包含头⽂件就可以了，⽽定义（int
e=12；）只能放在源⽂件中，定义如果放在头⽂件中，那么其他⽂件⼀包含，e就重定义了。

所以全局变量的声明可以放在头⽂件⾥，全局变量的定义只能放在.c源⽂件中。

c语言全局变量的作用域

c语言全局变量的作用域C语言全局变量的作用域是指C语言中声明的全局变量如何影响程序的行为。

它定义了在编译和运行时变量的作用域，以及变量有了什么影响。

学习C语言的程序员都应该了解全局变量的作用域，以有效地编写代码。

全局变量的定义C语言中的全局变量是定义在程序外部的变量，可以在整个程序中可用。

它们可以在程序的任何地方被访问，可以从任何函数中被调用或修改。

全局变量可以是可变的，也可以是不可变的，也可以是任何类型的变量，例如，整数、字符串、浮点数和指针。

在C语言中，全局变量是指定义在函数和对象之外的变量，它们在整个程序有效。

全局变量的作用域与它所在的文件无关，它们可以在程序中的任何位置被使用。

全局变量的作用全局变量可以用来在程序中共享信息，尤其是在程序的不同部分之间共享变量值。

这使得程序能够有效地在不同模块之间进行通信。

另外，全局变量可以用于存储状态和信息。

它们可以跟踪程序的执行状态，比如是否进行错误检查，是否调试程序等。

另外，全局变量可以改变静态数据结构，并扩展程序功能。

比如，可以更改排序算法来排序元素，或者设置全局变量，以指定程序是否以灵活模式执行等。

全局变量的缺点尽管全局变量在一定程度上可以改变程序执行行为，但是它们也存在一定的风险。

首先，全局变量会破坏程序的封装性，因为它们可以在多个模块中被访问，而这些模块可能来自不同的源文件。

这会导致程序变得混乱，难以维护。

另外，全局变量可以导致程序的不可重复性，因为它们的值可能被随机更改，而不经过程序的控制。

这可能会导致程序出现意想不到的崩溃，并且无法被重新启动。

最后，全局变量有可能被恶意破坏，因为它们可以从任何位置被更改和修改。

这样，恶意用户可能会对程序造成重大伤害，从而破坏数据完整性和程序安全性。

结论C语言全局变量的作用域可以影响程序的行为，它们可以用来在程序中共享信息，跟踪程序的执行状态，以及改变静态数据结构。

但是，它们也存在一定的风险，可能会破坏程序的封装性，导致程序的不可重复性，以及恶意破坏数据完整性，因此要牢记全局变量的正确使用。

Cc++中数组全局变量的定义声明与引用声明

Cc++中数组全局变量的定义声明与引⽤声明
数组声明⼀次，所有的定义声明有切仅有⼀次！
别⼈遇到的问题如下：
在声明定义时，定义数组如下：
int G_glob[100];
在其他⽂件引⽤时声明如下：
int *G_glob;
这样的操作，在vc中，是可以编译通过的，这种情况⼤家都⽐较模糊并且需要注意，数组与指针类似，但并不等于说对数组的声明起变量就是指针。

上⾯所说的的程序在运⾏时发现了问题，在引⽤声明的那个⽂件中，使⽤这个指针时总是提⽰内存访问错误，原来我们的连接程序并不把指针与数组等同，连接时，也不把他们当做同⼀个定义，⽽是认为是不相关的两个定义，当然会出现错误。

正确的使⽤⽅法是在引⽤声明中声明如下：
int G_glob[100];
最好是加上引⽤申明标识：
extern int G_glob[100];
更好的是：
另外需要说明的是，在引⽤声明中由于不需要涉及到内存分配，可以简化如下，这样在需要对全局变量的长度进⾏修改时，不⽤把所有的引⽤声明也全部修改了。

extern int G_glob[];
本来看到是说有引⽤链接的，结果最后没有我这⾥也只好结束了。

来⾃：janders 只知其名不知居。

c 变量定义规则

c 变量定义规则摘要：一、变量定义规则简介二、变量命名规则1.变量名的组成2.变量名的首字符限制3.变量名的长度限制4.变量名的命名规范三、变量类型及声明1.变量类型2.变量声明四、变量的赋值与使用1.变量的赋值2.变量的使用五、变量的作用域与生命周期1.变量的作用域2.变量的生命周期六、变量的注意事项1.变量使用中的错误2.变量的特殊处理正文：在编程中，变量是用于存储数据的重要概念。

为了保证程序的可读性和可维护性，我们需要遵循一定的规则来定义和使用变量。

本文将详细介绍C 语言中的变量定义规则。

一、变量定义规则简介变量定义规则主要包括变量命名规则、变量类型及声明、变量的赋值与使用、变量的作用域与生命周期等方面。

二、变量命名规则1.变量名由字母、数字和下划线组成，但不能以数字开头。

2.变量名的首字符不能是保留字，如if、else、while 等。

3.变量名的长度不能超过31 个字符。

4.变量名应遵循驼峰命名法，即多个单词组合在一起时，每个单词的首字母大写，除了第一个单词。

三、变量类型及声明1.变量类型包括整型、浮点型、字符型、指针型等。

2.变量声明指定变量的类型，如int a;声明一个整型变量a。

四、变量的赋值与使用1.变量赋值是将一个值分配给一个变量。

例如：int a = 10;表示将整数10 赋值给变量a。

2.变量使用是在程序中引用变量的值。

例如：printf("%d", a);表示输出变量a 的值。

五、变量的作用域与生命周期1.变量的作用域是指变量在程序中可访问的范围。

局部变量只能在声明它的函数内访问，全局变量则可以在整个程序范围内访问。

2.变量的生命周期是指变量在程序运行过程中的存在时间。

局部变量的生命周期从声明开始，直到函数结束；全局变量的生命周期从程序启动，直到程序结束。

六、变量的注意事项1.变量使用中的错误包括类型不匹配、变量未声明、变量名拼写错误等，应尽量避免。

C语言变量声明问题——变量定义一定要放在所有执行语句语句块的最前面吗？

C语⾔变量声明问题——变量定义⼀定要放在所有执⾏语句语句块的最前⾯吗？报错信息：error C2065: 'salary' : undeclared identifier#include <stdio.h>void main(){printf("我的成绩是100分！");//不使⽤变量int salary;//使⽤变量salary = 100;printf("我的成绩是%d分！",salary);return 0;}问题根源：编译器问题——C89和C99C89规定，在任何执⾏语句之前，在块的开头声明所有局部变量。

在C99以及C++中则没有这个限制，即在⾸次使⽤之前，可在块的任何位置都可以声明变量。

变量声明放在前⾯就不报错了······#include <stdio.h>void main(){int salary;//使⽤变量salary = 100;printf("我的成绩是100分！");//不使⽤变量printf("我的成绩是%d分！",salary);return 0;}不同风格利弊变量在函数开头定义：便于修改变量就近定义：便于阅读变量在块语句的开头定义：有的临时变量放在语句块开头，可以不⽤在函数开头定义，并且在使⽤完毕后释放空间，可以这么做，但不要⽆故添加花括号来提⾼代码的结构。

要达到最⼤的兼容跨平台性，还是放在函数开头定义吧使⽤哪种⽅式，看实际情况+个⼈喜好！我个⼈是⽐较喜欢就近定义的，觉得⽐较⽅便⼀点。

可是，现在使⽤的VC6.0，编译器可能是C89的，所以不得不⽤开头定义。

顺便提⼀提：该⽂件的后缀名为.c在⽹上查了⼀下，有许多说法，列举⼀⼆（意思⼤同⼩异）1.源⽂件保存为.c格式的话变量只能定义在最前，若保存为.cpp格式的话，变量定义较为灵活，不⽤在最前。