头文件数组初始化

我想在aa.h 中 加入
double aa[]={0.25,0.25,0.25,0.25};

编译器总是报错，请问怎么回事？ 写写

22 个解决方案

#1

具体代码

#2

变量必须定义在.c/.cpp文件内，否则头文件如果被多个.c/.cpp文件包含，这个变量就被定义多次，导致符号已经定义的链接错误

#3

设计头文件时不应该含有非inline函数和对象的定义。符号常量的定义和inline函数可以被重复定义多次，在编译期间，在可能的情况下，符号常量的 值会取代该名字的出现，这个过程为常量折叠。符号常量是任何const类型的对象。但是如下定义不符合 char *const buf = new char[10]，因为它的值不能在编译时确定，不能定义在头文件；

在头文件里，你只能写const double aa[4]={0.25,0.25,0.25,0.25}; 

#4

什么错可以贴出来嘛，这样怎么说呀，是不是说变量被重复定义？

#5

前面加个 static
要不,就用条件宏

#6

头文件最好自用做声明，如果你非得定义的话可以用
extern const double aa[]={0.25,0.25,0.25,0.25}; 

#7

楼上各位说的很有道理了，分清h文件和cpp文件的作用就好

#8

引用楼主 wcwyf001 的帖子:

我想在aa.h 中 加入 
double aa[]={0.25,0.25,0.25,0.25}; 

编译器总是报错，请问怎么回事？ 写写

头文件里不能做变量的定义 这样文件被多次的.c和.cpp调用的时候 造成了变量的重复定义 
所以写的定义的时候都写在.c或.cpp文件里
如果LZ非要那么做的啊 那就用#define 在头文件里直接定义好了

#9

你知道定义static意味着什么么？条件宏不能解决这个问题

引用 5 楼 du51 的回复:

前面加个 static 
要不,就用条件宏

#10

引用 2 楼 arong1234 的回复:

变量必须定义在.c/.cpp文件内，否则头文件如果被多个.c/.cpp文件包含，这个变量就被定义多次，导致符号已经定义的链接错误 

应该是这样子的，如果在头文件中定义  double aa[]={0.25,0.25,0.25,0.25}; 
那么aa是带有外部连接的，外部连接被多个头文件包含就会出错，
但如果是const ，static 就是带有内部连接的，编译可以通过。如果你这样定义，
const aa[]={0.25,0.25,0.25,0.25}; 或者  static aa[]={0.25,0.25,0.25,0.25}; 应该是不会编译出错的。
一般来说，把变量的定义放在头文件中很多情况下都是一个错误。


具体你可以看看下面：



C++编译时的连接
    　　1.声明
    　　一个声明将一个名称引入一个作用域;
    　　在c++中，在一个作用域中重复一个声明是合法的

    　　以下都是声明：
    int foo(int,int); //函数前置声明
    typedef int Int; //typedef 声明
    class bar; //类前置声明
    extern int g_var; //外部引用声明
    class bar; //类前置声明
    typedef int Int; //typedef 声明
    extern int g_var; //外部引用声明
    friend test; //友员声明
    using std::cout; //名字空间引用声明
    friend test; //友员声明
    using std::cout; //名字空间引用声明
    int foo(int,int); //函数前置声明
    　　在同一个作用域中你可以多次重复这些声明。
    　　有两种声明不能重复，那就是类成员函数及静态数据成员的声明
    class foo
    {
    　static int i;
    　static int i;//不可以
    　public:
    　　int foo();
    　　int foo();//不可以
    };
    2.定义
    　　一个定义提供一个实体(类型、实例、函数)在一个作用域的唯一描述。
    　　在同一作用域中不可重复定义一个实体。
    　　以下都是定义。
    int y;
    class foo ;
    struct bar ;
    foo* p;
    static int i;
    enum Color;
    const double PI = 3.1415;
    union Rep;
    void test(int p) {};
    foo a;
    bar b;
    　　3.编译单元
    　　当一个c或cpp文件在编译时，预处理器首先递归包含头文件，形成一个含有所有必要信息的单个源文件,这个源文件就是一个编译单元。这个编译单元会被编译成为一个与cpp文件名同名的目标文件(.o或是.obj)。连接程序把不同编译单元中产生的符号联系起来，构成一个可执行程序。
    　　4.*函数
    　　如果一个函数是*函数，那么这个函数不是类的成员函数，也不是友元函数。
    　　下面来看内部连接和外部连接
    　　内部连接：如果一个名称对于它的编译单元来说是局部的，并且在连接时不会与其它编译单元中的同样的名称相冲突，那么这个名称有内部连接(注：有时也将声明看作是无连接的，这里我们统一看成是内部连接的)。
    　　以下情况有内部连接:
    　　a)所有的声明
    　　b)名字空间(包括全局名字空间)中的静态*函数、静态友元函数、静态变量的定义
    　　c)enum定义
    　　d)inline函数定义(包括*函数和非*函数)
    　　e)类的定义
    　　f)名字空间中const常量定义
    　　g)union的定义
    　　外部连接:在一个多文件程序中，如果一个名称在连接时可以和其它编译单元交互，那么这个名称就有外部连接。
    　　以下情况有外部连接:
    　　a)类非inline函数总有外部连接。包括类成员函数和类静态成员函数
    　　b)类静态成员变量总有外部连接。
    　　c)名字空间(包括全局名字空间)中非静态*函数、非静态友元函数及非静态变量
    　　下面举例说明：
    　　a)声明、enum定义、union定义有内部连接
    　　所有的声明、enum定义及union定义在编译后不会产生连接符号，也就是在不同编译单元中有相同名称的声明及enum、union定义并不会在连接时发生发现多个符号的错误。
    // main.cpp
    typedef int Int; //typedef 声明，内部连接
    enum Color; //enum定义,内部连接
    union X //union定义，内部连接
    {
    　long a;
    　char b[10];
    };
    int main(void)
    {
    Int i = red;
    return i;
    }
    // a.cpp
    typedef int Int; //在a.cpp中重声明一个int类型别名，在连接时不会发生错误
    enum Color; //在a.cpp中重定义了一个enum Color，在连接时不会发生错误
    const Int i =blue; //const常量定义，内部连接
    union X //union定义，内部连接
    {
    　long a;
    　char b[10];
    };
    　　b)名字空间中静态*函数、静态友元函数、静态变量、const常量定义有内部连接
    // main.cpp
    namespace test
    {
    　int foo(); //函数声明，内部连接
    　static int i = 0; //名字空间静态变量定义，内部连接
    　static int foo() { return 0;} //名字空间静态函数定义，内部连接
    }
    static int i = 0; //全局静态变量定义，内部连接
    static int foo() {return 1;} //全局静态函数定义，内部连接
    const int k = 0; //全局const常量定义，内部连接
    int main(void)
    {
    　return 0;
    }
    //a.cpp
    namespace test
    {
    　int i = 0; //名字空间变量定义，外部连接
    　int foo() {return 0;} //名字空间函数定义，外部连接
    }
    int i = 0; //全局变量定义，外部连接
    int k = 0; //全局变量定义，外部连接
    int foo() { return 2;} //全局函数定义，外部连接
　在全局名字空间中，main.cpp中定义了静态变量i,常量k,及静态*函数foo等，这些都有内部连接。如果你将这些变量或函数的static或是const修饰符去掉，在连接时就会现multiply defined symbols错误，它们与a.cpp中的全局变量、全局函数发生冲突。
    c)类定义总有内部连接,而非inline类成员函数定义总有外部连接，不论这个成员函数是静态、虚拟还是一般成员函数，类静态数据成员定义总有外部连接。
    　　1.类的定义有内部连接。如果不是，想象一下你在4个cpp文件中include定义了类Base的头文件，在4个编译单元中的类Base都有外部连接，在连接的时候就会出错。
    　　看下面的例子:
    //main.cpp
    class B //类定义，内部连接
    {
    　static int s_i; //静态类成员声明，内部连接
    　public:
    　　void foo() { ++s_i;} //类inline函数，内部连接
    };
    struct D
    {
    　void foo(); //类成员函数声明，内部连接
    };
    int B::s_i = 0; //类静态数据成员定义，外部连接
    void D::foo() //类成员函数定义，外部连接
    {
    　cout << "D::foo in main.cpp" <
    }
    int main() //main函数，全局*函数，外部连接
    {
    　B b;
    　D d;
    　return 0;
    }
    //a.cpp
    class B
    {
    　int k;
    };
    struct D
    {
    　int d;
    };
    　　在这个例子中，main.cpp与a.cpp中都有class B和class D的定义，但在编译这两个cpp文件时并不发生link错误。
    　　2.类的非inline成员函数(一般，静态，虚拟都是)总有外部连接，这样当你include了某个类的头文件，使用这个类的函数时，就能连接到正确的类成员函数上，继续以上面为例子，如果把a.cpp中的struct D改为
    struct D //类定义
    {
    　int d;
    　void foo(); //类成员函数声明
    };
    void D::foo() //类成员函数定义，外部连接
    {
    　cout << " D::foo in a.cpp" <
    }
    　　这时main.cpp与a.cpp中的D::foo都有外部连接，在连接就会出现multiply defined symbols错。
    　　3.类的静态数据成员有外部连接，如上例的B::s_i,这样当你在main.cpp中定义了类静态数据成员，其它编译单元若使用了B::s_i,就会连接到main.cpp对应编译单元的s_i。
    　　d)inline函数总有内部连接，不论这个函数是什么函数
    // main.cpp
    inline int foo() { return 1;} //inline全局函数，内部连接
    class Bar //类定义，内部连接
    {
    　public:
    　　static int f() { return 2;} //inline 类静态函数，内部连接
    　　int g(int i) { return i;} //inline 类成员函数，内部连接
    };
    class Base
    {
    　public:
    　　inline int k()； //类成员函数声明，内部连接
    }；
    inline int Base::k(){return 5;} //inline 类成员函数，内部连接
    int main(void)
    {
    　return 0;
    }
    　　如果你的Base类是定义在Base.h中，而Base的inline 函数是在Base.cpp中定义的，那么在main.cpp中include "Base.h"编译不会出现问题，但在连接时会找不到函数k，所以类的inline函数最好放到头文件中，让每一个包含头文件的cpp都能找到 inline函数。
    　　现在对c++中的连接有了一个认识，能清楚的知道是什么原因产生连接时错误。当你在连接时产生连接不到的错误，这说明所有的编译单元都没有这个实体的外部连接；当你在连接时发现有多个连接实体，这说明有多个编译单元提供了同名的有外部连接的实体。同时，在进行程序设计时，也要注意不要使只有本编译单元用到的函数、类、变量等有外部连接，减少与其它编译单元的连接冲突。
    　　不过在这里没有说明template函数及template class的连接性，并且对一些特别的情况也没有作出说明(比如inline函数不能被inline)。

#11

编译通过不代表对！！！现在很多人总是觉得编译不报错就对了，这是非常严重得一个误解。

如果你一个变量在头文件定义，楼主一般得目的就是要定义一个全局变量，这个变量应该在整个工程都可以被访问到。
而static得含义是迫使那个变量只在某个文件可见。
假定你在头文件定义static int i=1;
且这个头文件分别被a.cpp和b.cpp包含
这种情况吓当然不会有编译错误。

可是你没有理解这个“没有错误”的实质是什么。这个实质就是在a.cpp和b.cpp里会分别定义一个名字叫i的整型变量，两个i毫无关系。在a.cpp里修改i，他不会导致b.cpp里的i变化，这一般来说都不是大家期望的东西

不知道你那一大段东西哪里抄来的，总之你这种用static修饰的方法在99％以上的情况都是错误的。把编译错误弄没不是你编程的目的，你的目的在于真正逻辑的正确性

引用 10 楼 lei_zhuyan 的回复:

引用 2 楼 arong1234 的回复:
变量必须定义在.c/.cpp文件内，否则头文件如果被多个.c/.cpp文件包含，这个变量就被定义多次，导致符号已经定义的链接错误 
 
应该是这样子的，如果在头文件中定义  double aa[]={0.25,0.25,0.25,0.25}; 
那么aa是带有外部连接的，外部连接被多个头文件包含就会出错， 
但如果是const ，static 就是带有内部连接的，编译可以通过。如果你这样定义， 
const aa[]={0.25,0.25,0.25,0.25}; 或者 …

#12

想了解更多的情况的话，可以找本电子书
《大规模C++程序设计》貌似里面的第二章

讲得很清楚。应该可以解决你的困惑。

#13

知道规则不知道内涵没什么用的

引用 12 楼 lei_zhuyan 的回复:

想了解更多的情况的话，可以找本电子书 
《大规模C++程序设计》貌似里面的第二章 

讲得很清楚。应该可以解决你的困惑。

#14

引用 9 楼 arong1234 的回复:

你知道定义static意味着什么么？条件宏不能解决这个问题 


引用 5 楼 du51 的回复:
前面加个 static 
要不,就用条件宏 

我知道.static只在本文件内有效..只有一个副本..不对吗?
这种用法多了去了.很多环境的初始化.都是这样用的.
给你个例子.

class CInitSock
{
public:
	CInitSock(BYTE minorVer = 2, BYTE majorVer = 2)
	{
		WSADATA wsaData;
		WORD sockVersion;
		sockVersion = MAKEWORD(minorVer, majorVer);
		if (::WSAStartup(sockVersion, &wsaData) != 0)
		{
			exit(0);
		}
	}

	~CInitSock()
	{
		::WSACleanup();
	}
};

static CInitSock g_SInitSock;

class DPZ_XML_INITIALIZER
{
public:
	DPZ_XML_INITIALIZER() {
		xmlInitParser();
		xmlKeepBlanksDefault(0);
	}
	virtual ~DPZ_XML_INITIALIZER() {
		xmlCleanupParser();
	}
};

static DPZ_XML_INITIALIZER g_xml_initializer;

以上都是在头文件中的..有什么问题吗?初始化环境很有用..

还有一种是本文件用的常量..也经常这样用.

给你个例子.

static const char *LOG_PRI_MAPPING[] = {"",
	"<SYS>",
	"<RES>",
	"<PRO>",
	"<DEB>",
	"<ALL>"
};

上面是一个头文件里的.

都好用的?我说错了吗?



要不,就用条件宏 
请注意,我说的"要不"这两个字..
我指的是不用static的话,,就用条件宏..
我给你个例子
cpp文件的最开始定义如下

#ifndef _BUFF_LOG_CPP_
#define _BUFF_LOG_CPP_
#endif

.h文件的最后定义如下

#ifdef _BUFF_LOG_CPP_
BuffLog g_BuffLog;
#else
extern BuffLog g_BuffLog;
#endif

数组也是同理..我一直在用..

请问有什么问题吗?

#15

enum{SIZE = 100;};

aa[SIZE] = {.................}

#16

enum{size = 10};//多了个分号^_^

int aa[] = {......};

#17

UP

#18

我支持阿荣的观点

// file: e2.h

extern int array[];

// file: e2.cpp

#include "e2.h"

int array[] = {0, 1, 2, 3, 4};

// file: e1.cpp

#include <stdio.h>
#include "e2.h"

void print_array() {
	int i;

	for (i = 0; i < 5; i++) {
		printf("%d ", array[i]);
	}
	printf("\n");
}

int main() {
	print_array();

	return 0;
}

#19

学习一下！

#20

up~~

#21

该回复于2011-03-14 10:17:08被版主删除

#22

喔喔.水你的贴.