四个例子说明C语言 全局变量

目录
  • 第一个例子
  • 第二个例子
  • 第三个例子
  • 第四个例子

我们知道,全局变量是C语言语法和语义中一个很重要的知识点,首先它的存在意义需要从三个不同角度去理解:

  • 对于程序员来说,它是一个记录内容的变量(variable);
  • 对于编译/链接器来说,它是一个需要解析的符号(symbol);
  • 对于计算机来说,它可能是具有地址的一块内存(memory)。

其次是语法/语义:

  • 从作用域上看,带static关键字的全局变量范围只能限定在文件里,否则会外联到整个模块和项目中;
  • 从生存期来看,它是静态的,贯穿整个程序或模块运行期间(注意,正是跨单元访问和持续生存周期这两个特点使得全局变量往往成为一段受攻击代码的突破口,了解这一点十分重要);
  • 从空间分配上看,定义且初始化的全局变量在编译时在数据段(.data)分配空间,定义但未初始化的全局变量**暂存(tentative definition)**在.bss段,编译时自动清零,而仅仅是声明的全局变量只能算个符号,寄存在编译器的符号表内,不会分配空间,直到链接或者运行时再重定向到相应的地址上。

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

第一个例子

#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语言 全局变量的文章就介绍到这了,更多相关C全局变量多多内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后支持我们!

(0)

相关推荐

  • C语言基础全局变量与局部变量教程详解

    目录 一:局部变量与全局变量 1.1:局部变量 1.2:全局变量 1.3:代码解释 1.4:const修饰的变量的修改 二:静态局部变量与静态全局变量 2.1:static关键字 2.2:静态局部变量 2.3:静态全局变量 2.4:汇总 三:全局函数与静态函数 3.1:全局函数 3.2:静态函数 3.3:汇总表 一:局部变量与全局变量 1.1:局部变量 局部变量:在函数内部定义的变量 ,auto可加可不加 作用域:从定义到本函数结束 生命周期:从定义到该函数结束 1.2:全局变量 全局变量:在函

  • C语言入门篇--局部全局变量的作用域及生命周期

    目录 1.变量的分类 1.1 局部变量 1.2 全局变量 1.3 知识点 1.3.1 就近原则 1.3.2 访问规则 1.3.3 有效范围 2.变量的使用 3.变量的作用域和生命周期 3.1 作用域 3.1.1 局部变量的作用域 3.1.2 全局变量的作用域 3.2 生命周期 3.2.1 局部变量的生命周期 3.2.2 全局变量的生命周期 1.变量的分类 1.1 局部变量 也称临时变量,在函数.代码块内定义,一般只可在代码块内部使用的变量. 1.2 全局变量 具有全局性,放在函数外,在同一___

  • 深入探讨C语言中局部变量与全局变量在内存中的存放位置

    C语言中局部变量和全局变量变量的存储类别(static,extern,auto,register) 1.局部变量和全局变量在讨论函数的形参变量时曾经提到,形参变量只在被调用期间才分配内存单元,调用结束立即释放.这一点表明形参变量只有在函数内才是有效的,离开该函数就不能再使用了.这种变量有效性的范围称变量的作用域.不仅对于形参变量,C语言中所有的量都有自己的作用域.变量说明的方式不同,其作用域也不同.C语言中的变量,按作用域范围可分为两种,即局部变量和全局变量.1.1局部变量局部变量也称为内部变量

  • C语言 全局变量和局部变量详解及实例

    C语言 全局变量和局部变量详解 核心内容: 1.局部变量和全局变量 变量按照作用域分为:全局变量和局部变量 全局变量的作用域:从定义位置开始到下面整个程序结束. 局部变量的作用域:在一个函数内部定义的变量只能在本函数内部进行使用. OK,上面的效果用Java语言实现一下: public class App1 { public static int k = 10;//相当于全局变量 public static void main(String[] args) { int i = 10;//局部变量

  • C语言宏定义结合全局变量的方法实现单片机串口透传模式

    何谓透传? 根据百度百科给出的定义如下: 透传,即透明传输(pass-through),指的是在通讯中不管传输的业务内容如何,只负责将传输的内容由源地址传输到目的地址,而不对业务数据内容做任何改变. 在现实单片机产品开发过程中,如果存在多个串口,在调试打印某个模块信息的时候,大多数人的做法是将所有模块的TX.RX.GND引出来,分别接到不同的调试口去,通过PC终端去将这些信息分别打印出来.这样子做难免会弄错,甚至非常繁琐,万一不小心还会接错导致模块烧坏. 于是,透传模式的出现就是为了解决这样的问

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

    1.局部变量能否和全局变量重名? 答:能,局部会屏蔽全局.要用全局变量,需要使用"::" 局部变量可以与全局变量同名,在函数内引用这个变量时,会用到同名的局部变量,而不会用到全局变量.对于有些编译器而言,在同一个函数内可以定义多个同名的局部变量,比如在两个循环体内都定义一个同名的局部变量,而那个局部变量的作用域就在那个循环体内. 2.如何引用一个已经定义过的全局变量? 答:extern 可以用引用头文件的方式,也可以用extern关键字,如果用引用头文件方式来引用某个在头文件中声明的全

  • 四个例子说明C语言 全局变量

    目录 第一个例子 第二个例子 第三个例子 第四个例子 我们知道,全局变量是C语言语法和语义中一个很重要的知识点,首先它的存在意义需要从三个不同角度去理解: 对于程序员来说,它是一个记录内容的变量(variable): 对于编译/链接器来说,它是一个需要解析的符号(symbol): 对于计算机来说,它可能是具有地址的一块内存(memory). 其次是语法/语义: 从作用域上看,带static关键字的全局变量范围只能限定在文件里,否则会外联到整个模块和项目中: 从生存期来看,它是静态的,贯穿整个程序

  • PHP URL参数获取方式的四种例子

    在已知URL参数的情况下,我们可以根据自身情况采用$_GET来获取相应的参数信息($_GET['name']);那,在未知情况下如何获取到URL上的参数信息呢? 第一种.利用$_SERVER内置数组变量 相对较为原始的$_SERVER['QUERY_STRING']来获取,URL的参数,通常使用这个变量返回的会是类似这样的数据:name=tank&sex=1如果需要包含文件名的话可以使用$_SERVER["REQUEST_URI"](返回类似:/index.php?name=t

  • go语言 全局变量和局部变量实例

    一.局部变量 1 定义在{}里面的变量时局部变量,只能在{}里面有效 2 执行到定义的那句话,开始分配内存空间,离开作用域自动进行释放 3 作用域,就是变量作用的范围 package main import "fmt" func test() { i := 111 fmt.Println("i=", i) } func main() { test() { i := 10 fmt.Printf("i=%v\n", i) } // i=12 错误 i

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

    前言 在C语言中使用extern 关键字来定义全局变量的时候,我们需要在.h文件和.c文件中重复定义,这种重复,导致了出错几率的增加. 今天,在整理自己的代码的时候,考虑到我写的代码从一至终都是在一个cpp文件里面.于是,想把自己的代码中的各个模块分离开来,以便更好地阅读和管理. 遇到的问题 我的做法是: 宏定义.结构体定义.函数声明以及全局变量定义放到一个head.h头文件中 函数的定义放到head.cpp中 main函数放到main.cpp中 然而却报错了,提示xxx变量在*.obj文件中已

  • Go语言使用字符串的几个技巧分享

    一.字符串底层就是一个字节数组 这真的非常重要,而且影响着下面的其他几个技巧.当你创建一个字符串时,其本质就是一个字节的数组.这意味着你可以像访问数组一样的访问单独的某个字节.例如,下面的代码逐个打印字符串中的每个字节以及对应字节数组中的每个字节: package main import "fmt" func main() { str := "hello" for i := 0; i < len(str); i++ { fmt.Printf("%b

  • java程序设计语言的优势及特点

    java语言是一种面向对象的程序设计语言吗 java语言是面向对象的程序设计语言 支持部分或绝大部分面向对象特性(类和实例.封装性.继承.多态)的语言即可称为基于对象的或面向对象的语言.Java跟C#是目前最流行的两门面向对象语言. 面向对象语言可以归类为: 1.基于对象的程序设计语言: 2.面向对象的程序设计语言. 面向对象编程具有以下优点: 1.易维护 采用面向对象思想设计的结构,可读性高,由于继承的存在,即使改变需求,那么维护也只是在局部模块,所以维护起来是非常方便和较低成本的. 2.易扩

  • 分享两种实现Winform程序的多语言支持的多种解决方案

    因公司业务需要,需要将原有的ERP系统加上支持繁体语言,但不能改变原有的编码方式,即:普通程序员感受不到编码有什么不同.经过我与几个同事的多番沟通,确定了以下两种方案: 方案一:在窗体基类中每次加载并显示窗体时,会自动递归遍历含文本显示的控件(Button,CheckBox,GroupBox,Label,LinkLabel,TextBox,StatusStrip,TabPage,ToolStrip,RadioButton,DateTimePicker,DataGridView,CheckedLi

  • jQuery 表单验证扩展(四)

    周末写的 jQuery 表单验证扩展(三) 这篇文章点击率过低,不知道是文章太失水准还是什么其他原因,这里写文章只是为了分享一下自己写代码的心得,同时也是巩固自己所学的东西!如果文章中存在问题,请大家多多斧正!本篇文章介绍jQuery 表单验证扩展中的控件值的比较 (一). 存在的问题 这篇文章和第一篇中提到的控件值之间的比较没有多大的区别,唯一更近的就是在样式的处理.同时就是对代码进行了简化.但是这里还是单独拿出来讲解一下,此文非常简单,所以不会有大篇幅的讲解. (二). 参数介绍 onFoc

随机推荐