关于c++内部链接和非类型模版参数的限制
2011-04-06 22:56
781 查看
在说内部连接与外部连接前,先说明一些概念。
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{RED,GREEN,BLUE};
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{red}; //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{blue}; //在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" <<endl;
}
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" <<endl;
}
这时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++中的连接有了一个认识,能清楚的知道是什么原因产生连接时错误。当你在连接时产生连接不到的错误,这说明所有的编译单元都没有这个实体的外部连接;当你在连接时发现有多个连接实体,这说明有多个编译单元提供了同名的有外部连接的实体。同时,在进行程序设计时,也要注意不要使只有本编译单元用到的函数、类、变量等有外部连接,减少与其它编译单元的连接冲突。
对于非类型模版参数,你不能使用浮点数(试了一下,发觉其实可以)、class类型的对象和内部链接对象。
如:
template <char const* name>
class MyClass {
…
};
char const* s = "hello";
MyClass<s> x; // ERROR: s is pointer to object with internal linkage
这里"hello"是个内部链接(internal linkage)对象
但是:
template <char const* name>
class MyClass {
…
};
extern char const s[] = "hello";
MyClass<s> x; // OK
(1) "hello"是字符串常量,因为不是“变量”,所以没有内部、外部链接属性。
有内部外部链接属性的是那个s。
(2) C++规定,有const修饰的变量,不但不可修改,还都将具有内部链接属性,也就是只在本文件可见。(又补充规定,extern const联合修饰时,extern将压制const这个内部链接属性。于是,extern char cosnt s[]将仍然有外部链接属性,但是还是不可修改的。
(3) 以下这段话是《c++ templates》原作者的感悟:
nontype template parameters要求是在编译或者链接时值必须是可知的。对于内部链接对象来说,对于其他编译单元不可见,而在编译期至少模板的实例化是共享的,但是如果内部链接对象可以作为template argument(模板实参)会发生语义上的错误,例如字符串文字量(如"abcx“)。他传递给模板的是个指针,而非他的值("abcx").况且如果还有一个"abcx"的话,也是传递的是地址,并且这两个地址从理论上说是不相同的(即使某些编译器会做优化,让其相同)。但是他对我们用户来说不相同。但同时我们要说两个字符串文字量的值是相同的。应该共享一个类的定义(注:这是我们使用者的角度来谈),而实际上编译器无法以值的方式传递这种常量,而以地址的方式传递常量。这样如果编译器生成了不同的类的实现,这就违法了模板给我的信息(相同值的非类型类型『nontype template parameters』模板参数生成的对象是共享一个实例的类的),因此编译器不应该生成相应的类的实现。
本文部分来自CSDN博客:http://blog.csdn.net/sophia_sy/archive/2007/02/10/1507077.aspx
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{RED,GREEN,BLUE};
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{red}; //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{blue}; //在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" <<endl;
}
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" <<endl;
}
这时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++中的连接有了一个认识,能清楚的知道是什么原因产生连接时错误。当你在连接时产生连接不到的错误,这说明所有的编译单元都没有这个实体的外部连接;当你在连接时发现有多个连接实体,这说明有多个编译单元提供了同名的有外部连接的实体。同时,在进行程序设计时,也要注意不要使只有本编译单元用到的函数、类、变量等有外部连接,减少与其它编译单元的连接冲突。
对于非类型模版参数,你不能使用浮点数(试了一下,发觉其实可以)、class类型的对象和内部链接对象。
如:
template <char const* name>
class MyClass {
…
};
char const* s = "hello";
MyClass<s> x; // ERROR: s is pointer to object with internal linkage
这里"hello"是个内部链接(internal linkage)对象
但是:
template <char const* name>
class MyClass {
…
};
extern char const s[] = "hello";
MyClass<s> x; // OK
(1) "hello"是字符串常量,因为不是“变量”,所以没有内部、外部链接属性。
有内部外部链接属性的是那个s。
(2) C++规定,有const修饰的变量,不但不可修改,还都将具有内部链接属性,也就是只在本文件可见。(又补充规定,extern const联合修饰时,extern将压制const这个内部链接属性。于是,extern char cosnt s[]将仍然有外部链接属性,但是还是不可修改的。
(3) 以下这段话是《c++ templates》原作者的感悟:
nontype template parameters要求是在编译或者链接时值必须是可知的。对于内部链接对象来说,对于其他编译单元不可见,而在编译期至少模板的实例化是共享的,但是如果内部链接对象可以作为template argument(模板实参)会发生语义上的错误,例如字符串文字量(如"abcx“)。他传递给模板的是个指针,而非他的值("abcx").况且如果还有一个"abcx"的话,也是传递的是地址,并且这两个地址从理论上说是不相同的(即使某些编译器会做优化,让其相同)。但是他对我们用户来说不相同。但同时我们要说两个字符串文字量的值是相同的。应该共享一个类的定义(注:这是我们使用者的角度来谈),而实际上编译器无法以值的方式传递这种常量,而以地址的方式传递常量。这样如果编译器生成了不同的类的实现,这就违法了模板给我的信息(相同值的非类型类型『nontype template parameters』模板参数生成的对象是共享一个实例的类的),因此编译器不应该生成相应的类的实现。
本文部分来自CSDN博客:http://blog.csdn.net/sophia_sy/archive/2007/02/10/1507077.aspx
相关文章推荐
- 非类型模板参数限制——不可以使用内部链接对象
- C++ 非类型参数的模版实参
- C++ 非类型参数的模版实参
- C2970: “vt::vector”: 模板参数, 涉及带有内部链接的对象的表达式不能用作非类型参数 备忘
- c++中关于数组作为函数参数并传递数组元素个数的几种有效方法的讨论
- c++ 自定义类模版产生链接错误的原因
- C++ Templates笔记 7 非类型模板参数
- 关于GCC中同时使用动态和静态库链接的操作参数和解释
- C++的泛型编程和限制参数类型的技术探讨
- 关于HyperLink的NavigateUrl属性的链接地址参数设置
- C++中关于二维数组作为函数参数传递的问题
- 关于c++有界数组模版的分析与应用
- 关于C/C++中可变参数的详细介绍(va_list,va_start,va_arg,va_end)
- 关于C++编译时内链接和外链接
- 你好,C++(26)如何与函数内部进行数据交换?5.1.3 函数参数的传递
- 关于HyperLink的NavigateUrl属性的链接地址带参数出错的问题
- [c++ primer plus]c++ 函数模版,类模版,实例化,具体化,模版作参数,模版的友元
- 关于MySql链接url参数的设置
- 关于VB的指针以及VB和C/C++间的参数传递
- C++ Template之非类型模板参数