我们假设我有一个这样的结构:
struct my_struct
{
int a;
int b;
}
我有一个函数应该为"a"或"b"设置一个新值.此函数还需要指定要设置的变量.一个典型的例子是这样的:
void f(int which, my_struct* s, int new_value)
{
if(which == 0)
s->a = new_value;
else
s->b = new_value;
}
由于我不会在这里写的原因,我无法将指针传递给a/b到f.所以我不能用my_struct :: a或my_struct :: b的地址调用f.我不能做的另一件事是在my_struct中声明一个向量(int vars [2])并将一个整数作为索引传递给f.基本上在f中我需要按名称访问变量.
以前的例子的问题是,在将来我计划向struct添加更多变量,在这种情况下,我将记得向f添加更多if语句,这对于可移植性是不利的.我能做的就是将f写为宏,如下所示:
#define FUNC(which)
void f(my_struct* s, int new_value) \
{ \
s->which = new_value; \
}
然后我可以调用FUNC(a)或FUNC(b).
这可行,但我不喜欢使用宏.所以我的问题是:有没有办法使用模板而不是宏来实现相同的目标？
编辑:我将尝试解释为什么我不能使用指针,我需要按名称访问变量.基本上,结构包含系统的状态.该系统需要在请求时"撤消"其状态.使用名为undo_token的接口处理撤消,如下所示:
class undo_token
{
public:
void undo(my_struct* s) = 0;
};
因此,由于多态性,我无法将指针传递给undo方法(mystruct也包含其他类型的变量).
当我向结构中添加一个新变量时,我通常还会添加一个新类,如下所示:
class undo_a : public undo_token
{
int new_value;
public:
undo_a(int new_value) { this->new_value = new_value; }
void undo(my_struct *s) { s->a = new_value}
};
问题是当我创建令牌时我不知道指向s的指针,因此我无法在构造函数中保存指向s :: a的指针(这将解决问题)."b"的类是相同的,只需要写"s-> b"而不是s-> a
也许这是一个设计问题:我需要每个变量类型的撤销令牌,而不是每个变量一个...
1> Daniel Earwi..：
要回答确切的问题,有,但它非常复杂,它纯粹是编译时的事情.(如果您需要运行时查找,请使用指向成员的指针 - 并且根据您更新的问题,您可能误解了它们的工作方式.)
首先,您需要一些可以在编译时用来表示"成员名称"的东西.在编译时元编程中,除了整数之外的所有东西都必须用类型来表示.所以你将使用一种类型来表示一个成员.
例如,存储一个人年龄的整数类型的成员,以及存储其姓氏的另一个成员:
struct age { typedef int value_type; };
struct last_name { typedef std::string value_type; };
然后你需要像map编译时那样查找的东西.我们叫它吧ctmap.让我们支持最多8名成员.首先,我们需要一个占位符来表示字段的缺失:
struct none { struct value_type {}; };
然后我们可以向前声明形状ctmap:
template <
class T0 = none, class T1 = none,
class T2 = none, class T3 = none,
class T4 = none, class T5 = none,
class T6 = none, class T7 = none
>
struct ctmap;
然后我们专门针对没有字段的情况:
template <>
struct ctmap<
none, none, none, none,
none, none, none, none
>
{
void operator[](const int &) {};
};
其原因很快就会明白(可能).最后,所有其他案例的定义:
template <
class T0, class T1, class T2, class T3,
class T4, class T5, class T6, class T7
>
struct ctmap : public ctmap
{
typedef ctmap base_type;
using base_type::operator[];
typename T0::value_type storage;
typename T0::value_type &operator[](const T0 &c)
{ return storage; }
};
这到底是怎么回事？如果你把:
ctmap person;
C++将person通过递归扩展模板来构建一个类型,因为它ctmap 继承自身,我们为第一个字段提供存储,然后在继承时丢弃它.当没有更多的领域时,这一切都会突然停止,因为所有人都可以参加比赛none.
所以我们可以说:
person[last_name()] = "Smith";
person[age()] = 104;
这就像在a中查找map,但在编译时,使用字段命名类作为键.
这意味着我们也可以这样做:
template
void print_member(ctmap &person)
{
std::cout << person[TMember()] << std::endl;
}
这是一个打印一个成员值的函数,其中要打印的成员是一个类型参数.所以我们可以这样称呼它:
print_member(person);
所以是的,你可以编写struct一个有点像编译时的东西map.
这不是世界上最干净的东西,但仍然很聪明.+1只是为了教我新的东西.
一个非常完整的答案,但它对我所需要的东西来说是一种矫枉过正.正如Dan说的那样,无论如何,你给我一个新的东西给了我+1.
+1阅读和实际理解Abrahams/Gurtovoy"C++模板元编程".
Abrahams是老兄 - 我曾经对boost-parameter提交了一个小改进,他向我解释说它需要修复,所以它在编译时运行在O(n)中.当你刚刚使用模板元编程的想法发现专家在睡眠中这样做时,这有点奇怪.
2> Mykola Golub..：
#include
#include
#include
struct my_struct
{
int a;
std::string b;
};
template
void set( TObject* object, TMember member, TValue value )
{
( *object ).*member = value;
}
class undo_token {};
template
class undo_member : public undo_token
{
TValue new_value_;
typedef TValue my_struct::* TMember;
TMember member_;
public:
undo_member(TMember member, TValue new_value):
new_value_( new_value ),
member_( member )
{}
void undo(my_struct *s)
{
set( s, member_, new_value_ );
}
};
int main()
{
my_struct s;
set( &s, &my_struct::a, 2 );
set( &s, &my_struct::b, "hello" );
std::cout << "s.a = " << s.a << std::endl;
std::cout << "s.b = " << s.b << std::endl;
undo_member um1( &my_struct::a, 4 );
um1.undo( &s );
std::cout << "s.a = " << s.a << std::endl;
undo_member um2( &my_struct::b, "goodbye" );
um2.undo( &s );
std::cout << "s.b = " << s.b << std::endl;
return 0;
}
3> Mustafa Serd..：
除了Daniel Earwicker的回答之外,我们可以在新的C++标准中使用可变参数模板来实现相同的目标.
template
struct Field {
typename T::value_type storage;
typename T::value_type &operator[](const T &c) {
return storage;
}
};
template
struct ctmap : public Field... {
};
此代码更清晰,没有固定的成员范围.您可以以相同的方式使用它
struct age { typedef int value_type; };
struct last_name { typedef std::string value_type; };
ctmap person;
person[last_name()] = "Smith";
person[age()] = 104;
你可以[更进一步](http://coliru.stacked-crooked.com/a/c5ec6cdf781525a1),在那里我们更接近像使用的领域.
4> j_random_hac..：
Mykola Golubyev的答案很好,但是通过使用指向成员的指针可以用作非类型模板参数的事实可以略微改进:
#include
#include
#include
struct my_struct
{
int a;
std::string b;
};
template
void set( TObject* object, TMember member, TValue value )
{
( *object ).*member = value;
}
class undo_token {};
template
class undo_member : public undo_token
{
// No longer need to store the pointer-to-member
TValue new_value_;
public:
undo_member(TValue new_value):
new_value_(new_value)
{}
void undo(my_struct *s)
{
set( s, Member, new_value_ );
}
};
int main()
{
my_struct s;
set( &s, &my_struct::a, 2 );
set( &s, &my_struct::b, "hello" );
std::cout << "s.a = " << s.a << std::endl;
std::cout << "s.b = " << s.b << std::endl;
undo_member um1( 4 );
um1.undo( &s );
std::cout << "s.a = " << s.a << std::endl;
undo_member um2( "goodbye" );
um2.undo( &s );
std::cout << "s.b = " << s.b << std::endl;
return 0;
}
这削减了每个实例的成员指针的成本undo_member.
京公网安备 11010802040832号