注册 登录
编程论坛 → C++教室

模板函数/模板类实例化问题

韩海0312 发布于 2017-06-12 16:27， 4362 次点击
问题描述
对下面每条带标签的语句，解释发生了什么实例化(如果有的话)，如果一个模板被实例化，解释为什么，
如果一个模板没有被实例化，解释为什么没有。

代码如下
程序代码：
template <typename T> class Stack { };

void f1(Stack<char>);                   // (a)

class Exercise {
    Stack<double> &rsd;                 // (b)
    Stack<int>    si;                   // (c)
};

int main() {
    Stack<char> *sc;                    // (d)
    f1(*sc);                            // (e)
    int iObj = sizeof(Stack< string >); // (f)
}
是不是这样的
1. a, b和d没有实例化。
2. c, f只实例化了类， 没有实例化任何类成员
3. e, 实例化了Stack<char> 同时实例化了copy 构造函数

上面的答案经过测试得出的结论，
但是不知道原理是怎样的？
难道是依据是否分配内存为准？ 如果是这样的话，c 和 f也没分配内存啊

求指教？


[此贴子已经被作者于2017-6-12 17:25编辑过]

14 回复
#2
l2919204972017-06-13 14:02
首先,我也是一个刚入行不久的人,不能确定我说的全对,但是我说出自己的看法,希望对你有所帮助

首先你申明了一个模版类,但是模版类中并没有使用typename T 这个T实例化类成员,你可以尝试sizeof(Stack<char/int/double>) 应该只有一个字节,这一个字节不代表分配了内存,只是相当于编译器在内存中为这个类做了一个标识.(大概是这样,具体你需要自行去查询)
你的以上所有Stack<T> 的成员都没有实例化.
就相当于 C 语言的 #define 一样.
#define T  (int)

class Stack<T>{
  T  a;//int  a
  T  b;//int  b
}
其实相当于把T字符简单替换而已.
希望对你有所帮助,如果我有说错的地方希望各位大神指出一下,这样我也能学习到新的东西,谢谢,共勉
#3
韩海03122017-06-14 19:23
回复 2楼 l291920497
我也是小菜，共同学习

分享下，我这这类问题的想法
我将上面的代码在加一个func的定义结果有些变化

程序代码：
template <typename T> class Stack { };

void f1(Stack<char>);                   // (a)

class Exercise {
    Stack<double> &rsd;                 // (b)
    Stack<int>    si;                   // (c)
};

void f1(Stack<char> g)                   // (g)
{
}

int main() {
    Stack<char> *sc;                    // (d)
    f1(*sc);                            // (e)
    int iObj = sizeof(Stack< string >); // (f)
}

（g）实例化，但未实例化任何成员
(g) 和 (a)的区别是一个是声明，一个是定义，（定义在调用时是要分配内存的）
是否实例化的关键是看是否将要分配该类型的对象内存（强调“将要”是因为函数定义时，型参其实没有分配内存，是在调用时定义的）
另外你说sizeof结果为一个字节的问题，原因在于我们的类没有数据成员（定义的非虚成员函数，不占实例的内存，它们只属于类型（不知道怎么表达对不对））
sizeof本来应该是0，但是类的对象实例一定是要占用一定内存的，否在无法使用这些对象，至于占用多大，要看使用的编译器

上面的a～g 应该是这样的

(a) 声明，不分配内存，不实例化
(b) 和 (d) 类是引用和指针不需要实例化
(c) 需要实例化，将会分配内存
(e) 实例化copy constructor
(f) 实例化
#4
韩海03122017-06-14 19:25
回复 3楼 韩海0312
你可以测试上面的结果，我已经测试过，解释不一定对，仅供参考
#5
rjsp2017-06-14 20:30
全是实例化，而且全是最直白的显式实例化（explicit instantiation）
#6
韩海03122017-06-15 09:37
回复 5楼 rjsp
你是说，使用显示实例化要使用的版本，避免这一类问题的发生么？
#7
rjsp2017-06-15 19:12
模版定义处之外，用具体类型替换掉模版的所有参数就是实例化
#8
韩海03122017-06-15 19:53
回复 7楼 rjsp
那你的说法，
(a) void f1(Stack<char>);
(b) Stack<double> &rsd;
(d) Stack<char> *sc;
这些该怎么解释呢， 这些用具体的实参替换形参， 但是这些没有实例化
#9
rjsp2017-06-15 21:15
你说的“实例化”是不是c++中的instantiation？
模版的实例化就是指由模版产生一个类
类的实例化就是指由类产生一个对象
#10
韩海03122017-06-16 14:35
回复 9楼 rjsp
你说的挺好， 我很赞同， 可是模板是什么时候实例化的呢，
这个才是我们一直关注的问题，我问题中描述中例子，他们遵循一个什么样的规则实例化，
我想知道这个
#11
rjsp2017-06-16 16:00
我不知道你口中的“实例化”是什么意思
我只说C++标准中的instantiation概念：
假如只有代码
template<typename T> void foo( T t )
{
}
template<> void foo<int>( int t )
{
}
的话，编译此代码，在obj文件中是找不到foo的任何实例的，即存在“生成 void foo<double>(double)、void foo<char*>(char*)、void foo<int>(int)……的规则”，但并不存在“void foo<double>(double)、void foo<char*>(char*)、void foo<int>(int)”

如果源代码写上
template void foo<double>(double)
template void foo<int>(int)
那么编译此代码后，在obj文件中就有了 template void foo<double>(double) 和 template void foo<int>(int)。
这就是所谓的 模板实例化。
传统的方法还有
int main( void )
{
    void foo<double>(double);
    foo( 1.2 ); // 这触发生成 void foo<double>(double)
    foo( 1 ); // 这触发生成 void foo<int>(int)
}
#12
韩海03122017-06-16 16:44
回复 10楼 韩海0312
我的模板instantiation， 就是指什么时候通过“规则”实例化出对应的类或者函数，

但是我不懂的是如
(a) void f1(Stack<char>); //这里为什么没有实例化出类Stack<char>
(b) Stack<double> &rsd;   //如果实例化模板，b和d 为什么不需要实例化出模板
(d) Stack<char> *sc;
在我觉得，模板是实例化一种类型或者函数的规则，
例如定义一种类型， 如（a） 这时候为什么不需要类型的（Stack<char>)完整定义，
在比如为什么(b) 和（d) 不要实例化出对应的类型，
我看到的一个解释是这样的：
notice the pointer/reference stuff: they don't require instantiation since no data is actually allocated(a pointer
is just a few bytes to contain the address, has no need to have all the data stored.. take a look at the pimpl idiom ).
Only when stuff is allocated then the template has to be completely resolved (and that happens at compile-time, that's why they usually need both declaration and definition.. there's no linking phase yet)
这种解释其实在说，例如指针32位机中都是4字节，不需要了解类型到底是真么样子的，只有在实例化类对象的时候踩需要实例化模板类，
这怎么又把类对象和模板类的实例化搞在一起，很是费解

抛开显示话声明和定义不讲，模板只有在使用时才实例化，这个“使用该怎么解释”？
#13
韩海03122017-06-19 10:26
回复 11楼 rjsp
是不是我说道哪里不对啊
#14
韩海03122017-06-19 11:43
回复 11楼 rjsp
我好像理解了这个问题，不知道我感觉是对的，你可你帮我分析一下我的理解么

我的理解是这样的：
1.其实模板的实例化是个编译链接问题
假如不考虑模板，我们写几个.cpp (a.cpp, b.cpp)文件，假如a.cpp 文件中使用了b.cpp文件里的类型
使用的时候不需要考虑是b.cpp中是否有定义，只要a.cpp中有b.cpp的类型声明就可以。
那现在呢，考虑模板
模板不是类或者函数，其实就是一个规范，或者说明(用来描述如何生成类或者函数)，所以在使用模板时，还有一个生成
模板对应类型的问题， 什么时候生成模板对用的类型或者函数，
1. 比如指针sc，它其实与类型无关，只与cpu寻址范围有关,所以不需要生成类型  //(d) Stack<char> *sc;
2. 引用呢，只是一个别名，生成类型是被引用一方(rsd)的事情， //Stack<double> &rsd
3. 再说函数声明中型参使用的模板，这个函数的声明这是表明在本文见中可以使用f1, 模板的实例化其实在f1的定义的时候 //(a) void f1(Stack<char>);
#15
rjsp2017-06-19 16:14
void f1(Stack<char>);                   // (a) 这是个函数声明，编译器只要知道 Stack<char> 是个类型就行了，是个什么行为的类型编译器不需要知道

class Exercise {
    Stack<double> &rsd;                 // (b) 引用 和 指针 是一样的，这里存的是个指针，它也不需要知道 Stack<char> 具体是什么行为。
    Stack<int>    si;                   // (c) 这里就需要知道 Stack<int> 有多大，否则就不知道Exercise的内存布局。因为只需要知道 Stack<int> 有多大，所以编译器只需要知道 Stack<int> 有那些成员变量。
};

int main() {
    Stack<char> *sc;                    // (d) 指针，同上
    f1(*sc);                            // (e) 这里会发生拷贝构造，自然需要知道 拷贝构造函数 是个啥。
    int iObj = sizeof(Stack< string >); // (f) 这里需要知道 Stack<int> 有多大，所以编译器只需要知道 Stack<int> 有那些成员变量。
}
1
©2025, BC-CN.NET
电脑版