http://www.cnblogs.com/bluestorm/archive/2011/11/04/2298126.html
说明:
写代码的时候头文件命名知道要加
#ifndef xxxx #define xxxx #endif
但是我把实现都放在了 .h文件中,然后出错了...所以头文件包含,只知其一不知其二,恩,就是所谓的
//a.h
#ifndef _A_H_
#define _A_H_
int max(int a, int b)
{
return a > b ? a:b;
}
#endif
//b.h
#include "a.h"
//c.h
#include "a.h"
//main.cpp
#include "b.h" //在这里会展开一个a.h中的max函数
#include "c.h" //在这里会展开一个a.h中的max函数
//也就是说在main.cpp中展开了两个max函数 ,所以编译的时候肯定会报错
讲解:
#include文件的一个不利之处在于一个头文件可能会被多次包含，为了说明这种错误，考虑下面的代码: //在一个文件中例如main.cpp中写了两次#include"x.h"
------main.cpp-------
#include "x.h"
#include "x.h"
显然，这里文件x.h被包含了两次，没有人会故意编写这样的代码。但是下面的代码:
------a.h------
#include "x.h"
------b.h------
#include "x.h"
-----main.cpp-----
#include "a.h"
#include "b.h"
看上去没什么问题。如果a.h和b.h都包含了一个头文件x.h。那么x.h在此也同样被包含了两次，只不过它的形式不是那么明显而已。
多重包含在绝大多数情况下出现在大型程序中，它往往需要使用很多头文件，因此要发现重复包含并不容易。要解决这个问题，我们可以使用条件编译。
#ifndef _HEADERNAME_H
#define _HEADERNAME_H
...//(头文件内容)
#endif
那么多重包含的危险就被消除了。当头文件第一次被包含时，它被正常处理，符号_HEADERNAME_H被定义为1。如果头文件被再次包含，通过条件编译，它的内容被忽略。符号_HEADERNAME_H按照被包含头文件的文件名进行取名，以避免由于其他头文件使用相同的符号而引起的冲突。
但是，你必须记住预处理器仍将整个头文件读入，即使这个头文件所有内容将被忽略。由于这种处理将托慢编译速度，所以如果可能，应该避免出现多重包含。
#ifndef只是防止了头文件被重复包含，但是无法防止变量被重复定义。
1 # vi test.h 2 ------------------------------- 3 #ifndef _TEST_H_ 4 #define _TEST_H_ 5 6 char add1[] = "www.shellbox.cn/n"; 7 char add2[] = "www.scriptbox.cn/n"; 8 int i = 10; 9 void test1(); 10 void test2(); 11 12 #endif |
1 # vi test.c
2 -------------------------------
3 #include <stdio.h>
4 #include "test.h"
5
6 extern i;
7 extern void test1();
8 extern void test2();
9
10 int main()
11 {
12 test1();
13 printf("ok/n");
14 test2();
15 printf("%d/n",i);
16 return 0;
17 }
|
1 # vi test1.c
2 -------------------------------
3 #include <stdio.h>
4 #include "test.h"
5
6 extern char add1[];
7
8 void test1()
9 {
10 printf(add1);
11 }
|
1 # vi test2.c
2 -------------------------------
3 #include <stdio.h>
4 #include "test.h"
5
6 extern char add2[];
7 extern i;
8
9 void test2()
10 {
11 printf(add2);
12 for (; i > 0; i--)
13 printf("%d-", i);
14 }
|
# Makefile
-------------------------------
test: test.o test1.o test2.o
test1.o: test1.c
test2.o: test2.c
clean:
rm test test.o test1.o test2.o
错误:
test-1.0编译后会出现"multiple definition of"错误。
错误分析:
由于工程中的每个.c文件都是独立的解释的，即使头文件有
#ifndef _TEST_H_
#define _TEST_H_
....
#enfif
在其他文件中只要包含了global.h就会独立的解释,然后每个.c文件生成独立的标示符。在编译器链接时，就会将工程中所有的符号整合在一起，由于文件中有重名变量，于是就出现了重复定义的错误。
解决方法
在.c文件中声明变量，然后建一个头文件(.h文件)在所有的变量声明前加上extern，注意这里不要对变量进行初始化。然后在其他需要使用全局变量的.c文件中包含.h文件。编译器会为.c生成目标文件，然后链接时，如果该.c文件使用了全局变量，链接器就会链接到此.c文件 。
1 # vi test.h 2 ------------------------------- 3 #ifndef _TEST_H_ 4 #define _TEST_H_ 5 6 extern i; 7 extern char add1[]; 8 extern char add2[]; 9 10 void test1(); 11 void test2(); 12 13 #endif |
1 # vi test.c
2 -------------------------------
3 #include <stdio.h>
4 #include "test.h"
5
6 int i = 10;
7 char add1[] = "www.shellbox.cn/n";
8 char add2[] = "www.scriptbox.cn/n";
9 extern void test1();
10 extern void test2();
11
12 int main()
13 {
14 test1();
15 printf("ok/n");
16 test2();
17 printf("%d/n",i);
18 return 0;
19 }
|
1 # vi test1.c
2 -------------------------------
3 #include <stdio.h>
4 #include "test.h"
5
6 void test1()
7 {
8 printf(add1);
9 }
|
1 # vi test2.c
2 -------------------------------
3 #include <stdio.h>
4 #include "test.h"
5
6 void test2()
7 {
8 printf(add2);
9 for (; i > 0; i--)
10 printf("%d-", i);
11
12 }
|
二、链接指示符:extern
如果希望调用其他程序设计语言(尤其是C)写的函数,那么,调用函数时必须告诉编译器使用不同的要求.例如,当这样的函数被调用时,函数名或参数排列的顺序可能不同,无论是C++函数调用它,还是用其他语言写的函数调用它.
程序员用链接指示符(linkage directive)告诉编译器,该函数是用其他的程序设计语言编写的.
链接指示符有两种形式:
单一语句(single statement)形式
复合语句(compound statement)形式
当复合语句链接指示符的括号中包含有#include时,在头文件中的函数声明都被假定是用链接指示符的程序设计语言所写的.
链接指示符不能出现在函数体中.
1 vi externC.cpp
2 -------------------------------------
3 #include <iostream>
4 extern "C" double sqrt(double);
5 int main()
6 {
7 using std::cout;
8 using std::endl;
9 double result = sqrt(25);
10 cout << "result = " << result << endl;
11 return 0;
12 }
编译: g++ externC.cpp
如果我们希望C++函数能够为C程序所用,我们也可以使用extern "C"链接指示符来使C++函数为C程序可用.
作为一种面向对象的语言，C++支持函数重载，而过程式语言C则不支持。函数被C++编译后在symbol库中的名字与C语言的不同。
例如，假设某个函数的原型为：void foo(int x, int y);
C编译器编译后在symbol库中的名字为_foo
C++编译器则会产生像_foo_int_int之类的名字。_foo_int_int这样的名字包含了函数名和函数参数数量及类型信息，C++就是靠这种机制来实现函数重载的。
为了实现C和C++的混合编程，C++提供了C链接交换指定符号extern "C"来解决名字匹配问题，函数声明前加上extern "C"后，则编译器就会按照C语言的方式将该函数编译为_foo，这样C语言中就可以调用C++的函数了。
1 cppExample.h 2 ----------------------------------- 3 #ifndef CPP_EXAMPLE_H 4 #define CPP_EXAMPLE_H 5 //被extern "C"限定的函数或变量首先是extern类型的； //extern是C/C++语言中表明函数和全局变量作用范围(可见性)的关键字 //该关键字告诉编译器，其声明的函数和变量可以在本模块或其它模块中使用. 6 //被extern "C"修饰的变量和函数是按照C语言方式编译和连接的； 7 extern "C" int add(int x, int y); 8 //extern int add(int x, int y); 9 #endif |
1 cppExample.cpp
2 -----------------------------------
3 #include "cppExample.h"
4
5 int add( int x, int y )
6 {
7 return x + y;
8 }
|
1 cFile.c
2 -----------------------------------
3 #include <stdio.h>
4 //这样会编译出错
5 //#include "cppExample.h"
6
7 extern int add(int x, int y);
8
9 int main(int argc, char* argv[])
10 {
11 printf("%d/n", add(2, 3));
12 return 0;
13 }
|
1 gcc cFile.c cppExample.cpp |
三、变量定义与声明的区别
我们在程序设计中，时时刻刻都用到变量的定义和变量的声明，可有些时候我们对这个概念不是很清楚，知道它是怎么用，但却不知是怎么一会事，下面我就简单的把他们的区别介绍如下:
变量的声明有两种情况:
(1) 一种是需要建立存储空间的(定义、声明)。例如：int a在声明的时候就已经建立了存储空间。
(2) 另一种是不需要建立存储空间的(声明)。例如：extern int a其中变量a是在别的文件中定义的。
前者是"定义性声明(defining declaration)"或者称为"定义(definition)",而后者是"引用性声明(referncing declaration)"。从广义的角度来讲声明中包含着定义，但是并非所有的声明都是定义，例如:int a它既是声明，同时又是定义。然而对于extern a来讲它只是声明不是定义。一般的情况下我们常常这样叙述，把建立空间的声明称之为"定义"，而把不需要建立存储空间称之为"声明"。很明显我们在这里指的声明是范围比较窄的，也就是说非定义性质的声明。
例如：在主函数中
int main()
{
extern int A; //这是个声明而不是定义，声明A是一个已经定义了的外部变量
//注意：声明外部变量时可以把变量类型去掉如：extern A;
dosth(); //执行函数
}
int A; //是定义，定义了A为整型的外部变量(全局变量)
外部变量(全局变量)的"定义"与外部变量的"声明"是不相同的,外部变量的定义只能有一次，它的位置是在所有函数之外，而同一个文件中的外部变量声明可以是多次的，它可以在函数之内(哪个函数要用就在那个函数中声明)也可以在函数之外(在外部变量的定义点之前)。系统会根据外部变量的定义(而不是根据外部变量的声明)分配存储空间的。对于外部变量来讲，初始化只能是在"定义"中进行,而不是在"声明"中。所谓的"声明"，其作用，是声明该变量是一个已在后面定义过的外部变量，仅仅是在为了"提前"引用该变量而作的"声明"而已。extern只作声明，不作定义。
用static来声明一个变量的作用有二：
(1) 对于局部变量用static声明，则是为该变量分配的空间在整个程序的执行期内都始终存在
(2) 外部变量用static来声明，则该变量的作用只限于本文件模块