我们使用Boost——所以使用那个库应该没问题。
但是我从来没有想过要创建一组模板来为整个数据类型类提供正确的专门化,而不是专门化为单个数据类型(我知道如何做)。
让我举个例子,试着把这个带到地球上来。我想要一组类,可以用作:
Initialized<T> t;
其中t是简单的基本类型、pods或数组。它不能是一个类,因为一个类应该有自己的构造函数,覆盖它的原始内存是一个糟糕的主意。
初始化基本上应该是memset(&t,0,sizeof(t));这样在处理遗留结构时,可以更容易地确保运行时代码与调试代码不存在差异。
在sdt=simple数据类型的地方初始化,应该简单地创建一个结构,该结构包装基础sdt,并使用编译器t()为该类型生成编译器定义的默认构造函数(它也可以是一个memset,不过简单地生成t()似乎更为优雅)。
这是一个尝试,对pods使用initialized<gt;,对sdts使用initialized<gt;:
// zeroed out PODS (not array)
// usage: Initialized<RECT> r;
template <typename T>
struct Initialized : public T
{
// ensure that we aren't trying to overwrite a non-trivial class
BOOST_STATIC_ASSERT((boost::is_POD<T>::value));
// publish our underlying data type
typedef T DataType;
// default (initialized) ctor
Initialized() { Reset(); }
// reset
void Reset() { Zero((T&)(*this)); }
// auto-conversion ctor
template <typename OtherType> Initialized(const OtherType & t) : T(t) { }
// auto-conversion assignment
template <typename OtherType> Initialized<DataType> & operator = (const OtherType & t) { *this = t; }
};
SDTs:
// Initialised for simple data types - results in compiler generated default ctor
template <typename T>
struct Initialised
{
// default valued construction
Initialised() : m_value() { }
// implicit valued construction (auto-conversion)
template <typename U> Initialised(const U & rhs) : m_value(rhs) { }
// assignment
template <typename U> T & operator = (const U & rhs) { if ((void*)&m_value != (void*)&rhs) m_value = rhs; return *this; }
// implicit conversion to the underlying type
operator T & () { return m_value; }
operator const T & () const { return m_value; }
// the data
T m_value;
};
我已经为t*进行了专门的初始化,以提供自然的指针行为。对于数组,我有一个initializedarray<gt;,它将元素类型和数组大小作为模板参数。但同样,我必须使用模板名来区分-我没有足够好地搜索MPL,以提供一个在编译时导致正确专门化的单个模板,所有这些都是从单个名称(理想情况下是初始化的<gt;)开始的。
我还希望能够提供重载的初始化类型名t、t init_value>,以便用户可以为非标量值定义默认的初始化值(或memset value)。
我很抱歉问了一些可能需要努力回答的问题。这似乎是我在自己的MPL阅读中无法克服的一个障碍,但也许在您的帮助下,我可以确定这个功能!
根据本叔叔下面的回答,我尝试了以下方法:
// containment implementation
template <typename T, bool bIsInheritable = false>
struct InitializedImpl
{
// publish our underlying data type
typedef T DataType;
// auto-zero construction
InitializedImpl() : m_value() { }
// auto-conversion constructor
template <typename U> InitializedImpl(const U & rhs) : m_value(rhs) { }
// auto-conversion assignment
template <typename U> T & operator = (const U & rhs) { if ((void*)&m_value != (void*)&rhs) m_value = rhs; return *this; }
// implicit conversion to the underlying type
operator T & () { return m_value; }
operator const T & () const { return m_value; }
// the data
T m_value;
};
// inheritance implementation
template <typename T>
struct InitializedImpl<T,true> : public T
{
// publish our underlying data type
typedef T DataType;
// auto-zero ctor
InitializedImpl() : T() { }
// auto-conversion ctor
template <typename OtherType> InitializedImpl(const OtherType & t) : T(t) { }
// auto-conversion assignment
template <typename OtherType> InitializedImpl<DataType> & operator = (const OtherType & t) { *this = t; }
};
// attempt to use type-traits to select the correct implementation for T
template <typename T>
struct Initialized : public InitializedImpl<T, boost::is_class<T>::value>
{
// publish our underlying data type
typedef T DataType;
};
然后尝试了一些使用测试。
int main()
{
Initialized<int> i;
ASSERT(i == 0);
i = 9; // <- ERROR
}
这将导致错误:*binary“=”:找不到接受“initializedimpl”类型的右侧操作数的运算符
'(或者没有可接受的转换)
但是,如果我直接实例化正确的基类型(而不是派生类型):
int main()
{
InitializedImpl<int,false> i;
ASSERT(i == 0);
i = 9; // <- OK
}
现在我可以把我当作任何一个旧的内景,这就是我想要的!
如果我尝试对结构执行相同的操作,则会出现完全相同的问题:
int main()
{
Initialized<RECT> r;
ASSERT(r.left == 0); // <- it does let me access r's members correctly! :)
RECT r1;
r = r1; // <- ERROR
InitializedImpl<RECT,true> r2;
r2 = r1; // OK
}
所以,正如您所看到的,我需要一些方法来告诉编译器将一个初始化函数升级为一个真正的t。
如果C++让我从基本类型继承,我可以只使用继承技术,一切都会很好。
或者,如果我有办法告诉编译器将父代中的所有方法都外推到子代,以便父代中的任何有效方法都对子代有效,我会没事的。
或者,如果我可以使用MPL或类型特征来typedef而不是继承我需要的东西,那么就没有子类,也没有传播问题。
思想?!
