C语言全局变量那些事儿

C语言全局变量那些事儿

(感谢网友 @我的上铺叫路遥 投稿)

作为一名程序员,如果说沉迷一门编程语言算作一种乐趣的话,那么与此同时反过来去黑一门编程语言就是这种乐趣的升华。今天我们就来黑一把C语言,好好展示一下这门经典语言令人抓狂的一面。

我们知道,全局变量是C语言语法和语义中一个很重要的知识点,首先它的存在意义需要从三个不同角度去理解:对于程序员来说,它是一个记录内容的变量(variable);对于编译/链接器来说,它是一个需要解析的符号(symbol);对于计算机来说,它可能是具有地址的一块内存(memory)。其次是语法/语义:从作用域上看,带static关键字的全局变量范围只能限定在文件里,否则会外联到整个模块和项目中;从生存期来看,它是静态的,贯穿整个程序或模块运行期间(注意,正是跨单元访问和持续生存周期这两个特点使得全局变量往往成为一段受攻击代码的突破口,了解这一点十分重要);从空间分配上看,定义且初始化的全局变量在编译时在数据段(.data)分配空间,定义但未初始化的全局变量暂存(tentative definition)在.bss段,编译时自动清零,而仅仅是声明的全局变量只能算个符号,寄存在编译器的符号表内,不会分配空间,直到链接或者运行时再重定向到相应的地址上。

我们将向您展现一下,非static限定全局变量在编译/链接以及程序运行时会发生哪些有趣的事情,顺便可以对C编译器/链接器的解析原理管中窥豹。以下示例对ANSI C和GNU C标准都有效,笔者的编译环境是Ubuntu下的GCC-4.4.3。

第一个例子

/* t.h */
#ifndef _H_
#define _H_
int a;
#endif

/* foo.c */
#include <stdio.h>
#include "t.h"

struct {
   char a;
   int b;
} b = { 2, 4 };

int main();

void foo()
{
    printf("foo:\t(&a)=0x%08x\n\t(&b)=0x%08x\n
        \tsizeof(b)=%d\n\tb.a=%d\n\tb.b=%d\n\tmain:0x%08x\n",
        &a, &b, sizeof b, b.a, b.b, main);
}

/* main.c */
#include <stdio.h>
#include "t.h"

int b;
int c;

int main()
{
    foo();
    printf("main:\t(&a)=0x%08x\n\t(&b)=0x%08x\n
        \t(&c)=0x%08x\n\tsize(b)=%d\n\tb=%d\n\tc=%d\n",
        &a, &b, &c, sizeof b, b, c);
	return 0;
}

Makefile如下:

test: main.o foo.o
	gcc -o test main.o foo.o

main.o: main.c
foo.o: foo.c

clean:
	rm *.o test

运行情况:

foo:	(&a)=0x0804a024
	(&b)=0x0804a014
	sizeof(b)=8
	b.a=2
	b.b=4
	main:0x080483e4
main:	(&a)=0x0804a024
	(&b)=0x0804a014
	(&c)=0x0804a028
	size(b)=4
	b=2
	c=0

这个项目里我们定义了四个全局变量,t.h头文件定义了一个整型a,main.c里定义了两个整型b和c并且未初始化,foo.c里定义了一个初始化了的结构体,还定义了一个main的函数指针变量。由于C语言每个源文件单独编译,所以t.h分别包含了两次,所以int a就被定义了两次。两个源文件里变量b和函数指针变量main被重复定义了,实际上可以看做代码段的地址。但编译器并未报错,只给出一条警告:

/usr/bin/ld: Warning: size of symbol 'b' changed from 4 in main.o to 8 in foo.o

运行程序发现,main.c打印中b大小是4个字节,而foo.c是8个字节,因为sizeof关键字是编译时决议,而源文件中对b类型定义不一样。但令人惊奇的是无论是在main.c还是foo.c中,a和b都是相同的地址,也就是说,a和b被定义了两次,b还是不同类型,但内存映像中只有一份拷贝。我们还看到,main.c中b的值居然就是foo.c中结构体第一个成员变量b.a的值,这证实了前面的推断——即便存在多次定义,内存中只有一份初始化的拷贝。另外在这里c是置身事外的一个独立变量。

为何会这样呢?这涉及到C编译器对多重定义的全局符号的解析和链接。在编译阶段,编译器将全局符号信息隐含地编码在可重定位目标文件的符号表里。这里有个“强符号(strong)”“弱符号(weak)”的概念——前者指的是定义并且初始化了的变量,比如foo.c里的结构体b,后者指的是未定义或者定义但未初始化的变量,比如main.c里的整型b和c,还有两个源文件都包含头文件里的a。当符号被多重定义时,GNU链接器(ld)使用以下规则决议:

  • 不允许出现多个相同强符号。
  • 如果有一个强符号和多个弱符号,则选择强符号。
  • 如果有多个弱符号,那么先决议到size最大的那个,如果同样大小,则按照链接顺序选择第一个。

像上面这个例子中,全局变量a和b存在重复定义。如果我们将main.c中的b初始化赋值,那么就存在两个强符号而违反了规则一,编译器报错。如果满足规则二,则仅仅提出警告,实际运行时决议的是foo.c中的强符号。而变量a都是弱符号,所以只选择一个(按照目标文件链接时的顺序)。

事实上,这种规则是C语言里的一个大坑,编译器对这种全局变量多重定义的“纵容”很可能会无端修改某个变量,导致程序不确定行为。如果你还没有意识到事态严重性,我再举个例子。

第二个例子

/* foo.c */
#include <stdio.h>;

struct {
    int a;
    int b;
} b = { 2, 4 };

int main();

void foo()
{
    printf("foo:\t(&b)=0x%08x\n\tsizeof(b)=%d\n
        \tb.a=%d\n\tb.b=%d\n\tmain:0x%08x\n",
        &b, sizeof b, b.a, b.b, main);
}

/* main.c */
#include <stdio.h>

int b;
int c;

int main()
{
    if (0 == fork()) {
        sleep(1);
        b = 1;
        printf("child:\tsleep(1)\n\t(&b):0x%08x\n
            \t(&c)=0x%08x\n\tsizeof(b)=%d\n\tset b=%d\n\tc=%d\n",
            &b, &c, sizeof b, b, c);
        foo();
    } else {
        foo();
        printf("parent:\t(&b)=0x%08x\n\t(&c)=0x%08x\n
            \tsizeof(b)=%d\n\tb=%d\n\tc=%d\n\twait child...\n",
            &b, &c, sizeof b, b, c);
        wait(-1);
        printf("parent:\tchild over\n\t(&b)=0x%08x\n
            \t(&c)=0x%08x\n\tsizeof(b)=%d\n\tb=%d\n\tc=%d\n",
            &b, &c, sizeof b, b, c);
    }
    return 0;
}

运行情况如下:

foo:	(&b)=0x0804a020
	sizeof(b)=8
	b.a=2
	b.b=4
	main:0x080484c8
parent:	(&b)=0x0804a020
	(&c)=0x0804a034
	sizeof(b)=4
	b=2
	c=0
	wait child...
child:	sleep(1)
	(&b):0x0804a020
	(&c)=0x0804a034
	sizeof(b)=4
	set b=1
	c=0
foo:	(&b)=0x0804a020
	sizeof(b)=8
	b.a=1
	b.b=4
	main:0x080484c8
parent:	child over
	(&b)=0x0804a020
	(&c)=0x0804a034
	sizeof(b)=4
	b=2
	c=0

(说明一点,运行情况是直接输出到stdout的打印,笔者曾经将./test输出重定向到log中,结果发现打印的执行序列不一致,所以采用默认输出。)

这是一个多进程环境,首先我们看到无论父进程还是子进程,main.c还是foo.c,全局变量b和c的地址仍然是一致的(当然只是个逻辑地址),而且对b的大小不同模块仍然有不同的决议。这里值得注意的是,我们在子进程中对变量b进行赋值动作,从此子进程本身包括foo()调用中,整型b以及结构体成员b.a的值都是1,而父进程中整型b和结构体成员b.a的值仍是2,但它们显示的逻辑地址仍是一致的。

个人认为可以这样解释,fork创建新进程时,子进程获得了父进程上下文“镜像”(自然包括全局变量),虚拟地址相同但属于不同的进程空间,而且此时真正映射的物理地址中只有一份拷贝,所以b的值是相同的(都是2)。随后子进程对b改写,触发了操作系统的写时拷贝(copy on write)机制,这时物理内存中才产生真正的两份拷贝,分别映射到不同进程空间的虚拟地址上,但虚拟地址的值本身仍然不变,这对于应用程序来说是透明的,具有隐瞒性。

还有一点值得注意,这个示例编译时没有出现第一个示例的警告,即对变量b的sizeof决议,笔者也不知道为什么,或许是GCC的一个bug?

第三个例子

这个例子代码同上一个一致,只不过我们将foo.c做成一个静态链接库libfoo.a进行链接,这里只给出Makefile的改动。

test: main.o foo.o
	ar rcs libfoo.a foo.o
	gcc -static -o test main.o libfoo.a

main.o: main.c
foo.o: foo.c

clean:
	rm -f *.o test

运行情况如下:

foo:	(&b)=0x080ca008
	sizeof(b)=8
	b.a=2
	b.b=4
	main:0x08048250
parent:	(&b)=0x080ca008
	(&c)=0x080cc084
	sizeof(b)=4
	b=2
	c=0
	wait child...
child:	sleep(1)
	(&b):0x080ca008
	(&c)=0x080cc084
	sizeof(b)=4
	set b=1
	c=0
foo:	(&b)=0x080ca008
	sizeof(b)=8
	b.a=1
	b.b=4
	main:0x08048250
parent:	child over
	(&b)=0x080ca008
	(&c)=0x080cc084
	sizeof(b)=4
	b=2
	c=0

从这个例子看不出有啥差别,只不过使用静态链接后,全局变量加载的地址有所改变,b和c的地址之间似乎相隔更远了些。不过这次编译器倒是给出了变量b的sizeof决议警告。

到此为止,有些人可能会对上面的例子嗤之以鼻,觉得这不过是列举了C语言的某些特性而已,算不上黑。有些人认为既然如此,对于一切全局变量要么用static限死,要么定义同时初始化,杜绝弱符号,以便在编译时报错检测出来。只要小心地使用,C语言还是很完美的嘛~对于抱这样想法的人,我只想说,请你在夜深人静的时候竖起耳朵仔细聆听,你很可能听到Dennis Richie在九泉之下邪恶的笑声——不,与其说是嘲笑,不如说是诅咒……

第四个例子

/* foo.c */
#include <stdio.h>

const struct {
    int a;
    int b;
} b = { 3, 3 };

int main();

void foo()
{
    b.a = 4;
    b.b = 4;
    printf("foo:\t(&b)=0x%08x\n\tsizeof(b)=%d\n
        \tb.a=%d\n\tb.b=%d\n\tmain:0x%08x\n",
        &b, sizeof b, b.a, b.b, main);
}

/* t1.c */
#include <stdio.h>

int b = 1;
int c = 1;

int main()
{
    int count = 5;
    while (count-- > 0) {
        t2();
        foo();
        printf("t1:\t(&b)=0x%08x\n\t(&c)=0x%08x\n
            \tsizeof(b)=%d\n\tb=%d\n\tc=%d\n",
            &b, &c, sizeof b, b, c);
        sleep(1);
    }
    return 0;
}

/* t2.c */
#include <stdio.h>

int b;
int c;

int t2()
{
    printf("t2:\t(&b)=0x%08x\n\t(&c)=0x%08x\n
        \tsizeof(b)=%d\n\tb=%d\n\tc=%d\n",
        &b, &c, sizeof b, b, c);
    return 0;
}

Makefile脚本:

export LD_LIBRARY_PATH:=.

all: test
	./test

test: t1.o t2.o
	gcc -shared -fPIC -o libfoo.so foo.c
	gcc -o test t1.o t2.o -L. -lfoo

t1.o: t1.c
t2.o: t2.c

.PHONY:clean
clean:
	rm -f *.o *.so test*

执行结果:

./test
t2:	(&b)=0x0804a01c
	(&c)=0x0804a020
	sizeof(b)=4
	b=1
	c=1
foo:	(&b)=0x0804a01c
	sizeof(b)=8
	b.a=4
	b.b=4
	main:0x08048564
t1:	(&b)=0x0804a01c
	(&c)=0x0804a020
	sizeof(b)=4
	b=4
	c=4
t2:	(&b)=0x0804a01c
	(&c)=0x0804a020
	sizeof(b)=4
	b=4
	c=4
foo:	(&b)=0x0804a01c
	sizeof(b)=8
	b.a=4
	b.b=4
	main:0x08048564
t1:	(&b)=0x0804a01c
	(&c)=0x0804a020
	sizeof(b)=4
	b=4
	c=4
	...

其实前面几个例子只是开胃小菜而已,真正的大坑终于出现了!而且这次编译器既没报错也没警告,但我们确实眼睁睁地看到作为main()中强符号的b被改写了,而且一旁的c也“躺枪”了。眼尖的读者发现,这次foo.c是作为动态链接库运行时加载的,当t1第一次调用t2时,libfoo.so还未加载,一旦调用了foo函数,b立马中弹,而且c的地址居然还相邻着b,这使得c一同中弹了。不过笔者有些无法解释这种行为的原因,有种说法是强符号的全局变量在数据段中是连续分布的(相应地弱符号暂存在.bss段或者符号表里),或许可以上报GNU的编译器开发小组。

另外笔者尝试过将t1.c中的b和c定义前面加上const限定词,编译器仍然默认通过,但程序在main()中第一次调用foo()时触发了Segment fault异常导致奔溃,在foo.c里使用指针改写它也一样。推断这是GCC对const常量所在地址启用了类似操作系统写保护机制,但我无法确定早期版本的GCC是否会让这个const常量被改写而程序不会奔溃。

至于volatile关键词之于全局变量,自测似乎没有影响。

怎么样?看了最后一个例子是否有点“不明觉厉”呢?C语言在你心目中是否还是当初那个“纯洁”、“干净”、“行为一致”的姑娘呢?也许趁着你不注意的时候她会偷偷给你戴顶绿帽,这一切都是通过全局变量,特别在动态链接的环境下,就算全部定义成强符号仍然无法为编译器所察觉。而一些IT界“恐怖分子”也经常将恶意代码包装成全局变量注入到root权限下存在漏洞的操作序列中,就像著名的栈溢出攻击那样。某一天当你傻傻地看着一个程序出现未定义的行为却无法定位原因的时候,请不要忘记Richie大爷那来自九泉之下最深沉的“问候”~

或许有些人会偷换概念,把这一切归咎于编译器和链接器身上,认为这同语言无关,但我要提醒你,正是编译/链接器的行为支撑了整个语言的语法和语义。你可以反过来思考一下为何C的胞弟C++推出“命名空间(namespace)”的概念,或者你可以使用其它高级语言,对于重定义的全局变量是否能通过编译这一关。

所以请时刻谨记,C是一门很恐怖的语言!

P.S.题外话写在最后。我无意挑起语言之争,只是就事论事地去“黑(hack)一门语言而已,而且要黑就要黑得有理有力有层次,还要带点娱乐精神。其实黑一门语言并非什么尖端复杂的技术,个人觉得起码要做到两点:

  • 亲自动手写测试程序。动手写测试程序是开发人员必备的基础技能,只有现成的代码才能让人心服口服,那些只会停留在口头上的争论只能算作cheap hack。
  • 测试程序不能依赖于不成熟的代码。软件开发99%以上的bug都是基于不合格(substandard)开发人员导致,这并不能怪罪于语言以及编译器本身。使用诸如#define TRUE FALSE或者#define NULL 1之类的trick来黑C语言只能证明此人很有娱乐精神而不是真正的”hack value”,拿老北京梨园行当里的一句话——“那是下三滥的玩意儿”。

(全文完)


关注CoolShell微信公众账号可以在手机端搜索文章

(转载本站文章请注明作者和出处 酷 壳 – CoolShell ,请勿用于任何商业用途)

——=== 访问 酷壳404页面 寻找遗失儿童。 ===——
好烂啊有点差凑合看看还不错很精彩 (22 人打了分,平均分: 4.32 )
Loading...

C语言全局变量那些事儿》的相关评论

  1. 最后一个例子不能说明c语言恐怖吧?我认为这只是动态链接机制的一个特点:它不做类型检查,而可能引起的一个问题而已。动态库的特点是运行时调用,因此它不会做太多的假设和限定是合理的,正如C语言本身也允许类型的强制转换和赋值,这是合法的行为,但这是“不安全”的。所以,它的“恐怖“反映可它的灵活和强大,言行不一也只是使用者对它的错误使用。换句话说:谁这样用全局变量谁傻x了,哈哈~~!

  2. 这和语言无关, 这是动态链接时的全局符号介入现象(Global Symbol Interpose). 具体可看 “程序员的自我修养” p217 ~ p218. 下面是文字引用该书:
    “当一个符号需要被加入全局符号表时, 如果相同的符号名已经存在, 则后加入的符号被忽略.”

  3. 高端黑,链接的时候只认符号的,类型神马的早没了,所标识的内存也是同一段内存,以最大的为准,所以你说它是指针它就是指针,你说它是整形就是整形,lz对C了解还不够透彻

  4. 题外话
    struct结构中的成员名是b;struct结构的一个实例也是b;另一文件中还有个int类型的b;
    这种写法值得推荐么?

    反正我不趟这浑水

  5. const限定词的变量是被合并到.text段中了,而.text段是只读的,这个操作系统管理的。对.text字段进行写操作就会出现Segment fault了。

  6. 原来如此:Assuming all data is initialized, both static const and external (global) const will go in text and both non-const-qualified static and non-const-qualified external will go in data. As for bss, modern binary formats like ELF actually have separate bss for constant and nonconstant zero data.
    @noahsarkzhang

  7. 这个问题其实跟C语言的符号决议策略有关。
    正式因为c语言是一个文件一个o来链接的,所以GCC不能对处于不同文件的相同名称的全局变量进行预判,而且GCC的linker也不能识别类型,所以导致了这个问题的出现,而且也是C语言的一个特点。
    C语言有强类型与弱类型之分,初始化了的全局变量属于强类型,而没有初始化的属于弱类型。GCC的linker对于多个o文件中即有强类型也有弱类型的策略是:按照强类型的大小来链接,链接后的目标文件只有一个强类型引用,即初始化了的那个。如果初始化了的强类型大小大于其他的弱类型,则GCC linker不会报出警告,如果小于则会报一条警告信息提示,运行时会出错。
    其实这个特性可以用来判断链接的不同版本的库引用,比如pthread的多线程版本还是单线程。这个C语言的特性在《程序员的自我修养》一书中有详细解释。不能说C语言恐怖,只是C比较合适黑客使用吧。

  8. 皓老大, 虽然很长知识, 从没想过这种东西。 但是我也赞同ls @E7的观点, 第三个例子 链接库时没有 进行强符号的覆盖检查, 这是链接时的问题了吧? 虽然 我也觉得这个问题好坑, 但是编程时注意一下域的概念就可以避免了。可否这样理解:”语言没有完美, 我们在了解语言特性的基础上,进行程序设计时尽可能的防止写出坑的代码” 。 您在电话面试我的时候,给我提出的种种意见,我一直都记得,也在自我反省。。

  9. 要说什么东西麻烦先确定论域。
    ISO C没有正式的“全局”、(作为名词的)variable和symbol的概念,对memory的概念也相当含混(不保证能有你想象的“地址”关联),更没有所谓的.bss和.text。虽然tentative definition这种槽点满载的渣特性倒的确是正儿八斤的玩意儿,不过完全不是这篇文章说的意思。
    直接说吧——这篇文章在说什么方言的什么实现?

  10. 在大多数语言中, 全局变量(例如Java中的public static变量)都是一把双刃剑,很强大但也很危险。对C语言掌控力不够的时候能不用全局变量就不要用,毕竟很多时候都是可以避免的。

  11. 哥哥,请不要在头文件中定义变量,请通过extern来声明变量。
    请在.c中定义变量,如果不想变量被其他模块引用,请在变量前加上stastic。

    在头文件中定义变量,是导致你说列举的编译器混乱的根源。

  12. 不错,又学习了。gcc貌似有些编译选项可以让编译条件变得很严格,排除掉一些runtime error;另一方面,一些linux开始渐渐不再采用gcc作为默认的编译器,这是不是也在证明gcc在诸多方面的不完善呢?

  13. 蛮子罗 :
    难道我错了吗?
    /* t.h */
    #ifndef _H_
    #define _H_
    int a;
    #endif
    会有两次定义吗? 不是通过符号被选择编译了吗? 编译main.c时,符号_H_被定义,在编译foo.c的时候这个地方不编译啊,怎么会定义两次int a;

    会的,因为编译是以单个.c文件进行的。 变量和函数不一样,变量如果不加extern就表示定义,而函数则不同。

  14. 我对作者文章中的提到的”还定义了一个main的函数指针变量”的说法不是很理解。这应该是一个单纯的函数声明啊。
    不知道是不是我的理解上有问题。

  15. #include

    const struct {
    int a;
    int b;
    } b = { 3, 3 };

    int main();

    void foo()
    {
    b.a = 4;
    b.b = 4;
    printf(“foo:\t(&b)=0x%08x\n\tsizeof(b)=%d\n
    \tb.a=%d\n\tb.b=%d\n\tmain:0x%08x\n”,
    &b, sizeof b, b.a, b.b, main);
    }
    b 不是const吗?在foo里面不能被修改吧,我在自己的vs2013上测试,编译是不能通过的

  16. kulong0105 :

    蛮子罗 :
    难道我错了吗?
    /* t.h */
    #ifndef _H_
    #define _H_
    int a;
    #endif
    会有两次定义吗? 不是通过符号被选择编译了吗? 编译main.c时,符号_H_被定义,在编译foo.c的时候这个地方不编译啊,怎么会定义两次int a;

    会的,因为编译是以单个.c文件进行的。 变量和函数不一样,变量如果不加extern就表示定义,而函数则不同。

    这个回复我不太明白,就算foo.c和main.c单独编译,由于宏的作用,不是会保证头文件只会被定义一次吗?还请高人明示啊!

  17. @hmgle
    不好意思,今天才看到回复您。根据您的回复,您不觉得您的说法正好反了吗。t1.c中先出现的b、c符号,然后在运行时动态链接器才装载libfoo.so,libfoo.so中的符号反而不应该覆盖前一个符号才对。而且我用readelf -r命令查看了test的重定位信息,其中根本就没有有关于b、c的符号,证明此时bc符号已经解析了。对于出现的问题我在网上了只找到了一句话可能能够解释:“如果多个不同的动态库,拥有相同的全局变量名,则最后加载的动态库中的全局变量会冲掉之前加载的全局变量,导致结果异常(程序正常工作)”。最后把网址也发给您:http://blog.csdn.net/zdl1016/article/details/9015447,一口气给您说了这么多,如果有不正确的地方,欢迎您批评指正。

  18. @mazinkaiser
    你没有明白这段话“当一个符号需要被加入全局符号表时, 如果相同的符号名已经存在, 则后加入的符号被忽略”的意思。
    当链接阶段时,因为符号表已经有 b 这个符号了,’struct { int a; int b;} b = { 3, 3 };’ 这里的b 就不会覆盖原来的b, 经过重定位之后, b.a = 4 操作的实际就是 b 的地址,相当于 b = 4,b.b = 4 实际上操作的是 c 的地址,相当于执行了 c=4

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*