w*******t
发帖数: 62 | 1 看神贴看到一道题，想问问有什么好的解法？
Given two classes:
class B
{
public:
B(args_1);
B(args_2);
// and many constructors with different arg lists
};
class D : public B
{
public:
D(args_1) : B(args_1) {}
D(args_2) : B(args_2) {}
// and many constructors with different signatures similarly implemented
// some additional stuff specific to D
};
Assume that the arg list for B's constructors are quite long and may be
revised pretty often in the future, in which case D's constructors have
to be recoded correspondingly. Duplicating the update by copy-and-paste
will certainly work here. Can you propose a better way so that the
update can be done in one place without copy-and-paste duplication? |
a***e
发帖数: 1140 | |
w*******t
发帖数: 62 | 3 能举个例子说明一下吗？ 谢谢了
【在 a***e 的大作中提到】
: template
|
a***e
发帖数: 1140 | 4 template
class B
{
public:
B(T arg) {}
};
template<>
class B
{
public:
B(T1 arg) {}
};
...
template
class D : public B
{
public:
D(T arg) : B(arg) {}
};
class D does not need to change.
suppose class B has other new c'tors, it just need to add specification
template class to refine it. |
h*c
发帖数: 1859 | 5 我的理解是人家说
ctor的list太长,而且容易换,
你的这个好像没有解决这个问题
【在 a***e 的大作中提到】
: template
: class B
: {
: public:
: B(T arg) {}
: };
: template<>
: class B
: {
: public:
|
t****t
发帖数: 6806 | 6 呃, 看到第一个回贴我以为他懂的
看到第二个回贴我才知道他是装懂的
这个答案是这样的
class B
{
public:
B(args_1);
B(args_2);
// and many constructors with different arg lists
};
class D : public B
{
public:
template D(T args_1) : B(args_1) {}
template D(T1 args_1, T2 args_2) : B(args_1, args
_2) {}
/* ...按参数个数写出D::D的template */
};
并不是把B变成模板.
当然, 如果允许C++11的话, 就直接在D里写using B::B; 就可以了.
不过, 这个特性目前gcc还没支持. 如果用支持的特性, 可以用variadic template (
supported in gcc 4.3+), 这样就只要写一个模板就可以了, 不用按个数:
template D(T... args) : B(args...) {}
【在 h*c 的大作中提到】
: 我的理解是人家说
: ctor的list太长,而且容易换,
: 你的这个好像没有解决这个问题
|
w*******t
发帖数: 62 | 7 多谢～～
按参数个数写ctor，没想到啊。
当时看c++ prime的时候，看到derived class把base class参数列表又写一遍，就觉得
有点duplicated，以后base class要是改了，derived class也要跟着改。
【在 t****t 的大作中提到】
: 呃, 看到第一个回贴我以为他懂的
: 看到第二个回贴我才知道他是装懂的
: 这个答案是这样的
: class B
: {
: public:
: B(args_1);
: B(args_2);
: // and many constructors with different arg lists
: };
|
u**r
发帖数: 663 | 8 可以给args造个单独的class，然后B,D都只要一个构造函数就好了，至于args怎么变都
在args类里头处理好，这样对args的调整只要做一次。
前面thrust 给的答案能解释一下吗，看不懂，很少用template |
w*******t
发帖数: 62 | 9 我的理解是，为不同个数的构造函数写一个template。比如说，有一个的，就写一个；
有两个的，就写两个。thrust的答案里就提到了这两种。再之后，有三个就写三个。
到用的时候，自动匹配相应个数的ctor。
不知道理解的对不对。
【在 u**r 的大作中提到】
: 可以给args造个单独的class，然后B,D都只要一个构造函数就好了，至于args怎么变都
: 在args类里头处理好，这样对args的调整只要做一次。
: 前面thrust 给的答案能解释一下吗，看不懂，很少用template
|
u**r
发帖数: 663 | 10 也就是说只要参数个数匹配，参数顺序可以通过调整template类型顺序实现。
那如果同时存在两个构造函数 B(int, double), B(double, int)，是不是就不行了呢
？当然这种定义没啥实际意义。
【在 w*******t 的大作中提到】
: 我的理解是，为不同个数的构造函数写一个template。比如说，有一个的，就写一个；
: 有两个的，就写两个。thrust的答案里就提到了这两种。再之后，有三个就写三个。
: 到用的时候，自动匹配相应个数的ctor。
: 不知道理解的对不对。
|
|
|
r****t
发帖数: 10904 | 11 template 会自动 match 类型的。
【在 u**r 的大作中提到】
: 也就是说只要参数个数匹配，参数顺序可以通过调整template类型顺序实现。
: 那如果同时存在两个构造函数 B(int, double), B(double, int)，是不是就不行了呢
: ？当然这种定义没啥实际意义。
|
t****t
发帖数: 6806 | 12 you are supposed to match D's ctor with B's, not changing B's ctor (that is,
changing the design) into one.
you need medium level introductory c++ book to learn template.
【在 u**r 的大作中提到】
: 可以给args造个单独的class，然后B,D都只要一个构造函数就好了，至于args怎么变都
: 在args类里头处理好，这样对args的调整只要做一次。
: 前面thrust 给的答案能解释一下吗，看不懂，很少用template
|
t****t
发帖数: 6806 | 13 correct.
【在 w*******t 的大作中提到】
: 我的理解是，为不同个数的构造函数写一个template。比如说，有一个的，就写一个；
: 有两个的，就写两个。thrust的答案里就提到了这两种。再之后，有三个就写三个。
: 到用的时候，自动匹配相应个数的ctor。
: 不知道理解的对不对。
|
t****t
发帖数: 6806 | 14 you don't need to "adjust template type order". template will generate
correct typed function (in this case, constructor) according to the
invocation (implicit instantiation), and that's exactly why template ever
existed.
【在 u**r 的大作中提到】
: 也就是说只要参数个数匹配，参数顺序可以通过调整template类型顺序实现。
: 那如果同时存在两个构造函数 B(int, double), B(double, int)，是不是就不行了呢
: ？当然这种定义没啥实际意义。
|
b******i
发帖数: 914 | 15 我觉得utar的意思是，如果B里面本身存在参数个数相同，但implementation不同的多
个ctors，那么如果按照thrust的实现，在D里面，按照参数个数的话，相应template只
有一个。那么如何调用B里面多个不同的ctors呢？
另外，如果B的ctors参数个数也会be revised in the future，如其中参数最多的ctor从原来的10个参数
增加到100，D的实现里面岂不是要增加90个ctors?
【在 t****t 的大作中提到】
: you don't need to "adjust template type order". template will generate
: correct typed function (in this case, constructor) according to the
: invocation (implicit instantiation), and that's exactly why template ever
: existed.
|
t****t
发帖数: 6806 | 16 if the two constructors of B can be distinguished, then D's two
instantiations can be distinguished.
suppose you have
B::B(const char*, int);
B::B(int, const char*);
B::B(double, float);
and template:
template
D::D(T1 t1, T2 t2) : B(t1, t2) {}
you can write
B b1("abc", 1), b2(2, "def"), b3(1.234, 5.678f);
D d1("ABC", 3), d2(4, "DEF"), d3(10.987, 6.543f);
clear enough?
as for your other question, if you have a 100 parameter constructor, you do
have to write 100 parameter template for D as well. this should be extremely
rare though. besides you can still use variadic template i mentioned.
ctor从原来的10个参数
【在 b******i 的大作中提到】
: 我觉得utar的意思是，如果B里面本身存在参数个数相同，但implementation不同的多
: 个ctors，那么如果按照thrust的实现，在D里面，按照参数个数的话，相应template只
: 有一个。那么如何调用B里面多个不同的ctors呢？
: 另外，如果B的ctors参数个数也会be revised in the future，如其中参数最多的ctor从原来的10个参数
: 增加到100，D的实现里面岂不是要增加90个ctors?
|
