C++ 类型双关 类
C++ type punning with classes
我正在编写一些包装 std::unordered_map 类型的 C++ 代码,我想在其中隐藏基础类型并将其呈现为另一种类型。更具体地说,我想用另一种类型包装 std::unordered_map 中的 std::pair。为了争论,让我们假设包装看起来像这样......
template <typename ActualT >
class wrapper final
{
private:
ActualT actual_;
public:
//Some constructors...
typename ActualT::first_type & get_first()
{
return actual_.first;
}
typename ActualT::second_type & get_second()
{
return actual_.second;
}
};
我的理由是,由于包装器 class 只有一个成员是它所包装的确切类型,将引用从原始类型转换为包装器类型应该没问题,但类型兼容性for structs 声明成员应该具有相同的类型和名称以使类型兼容。以这种方式使用类型双关是否会导致未定义的行为或对齐问题?
using my_map = std::unordered_map < int, int >;
my_map m;
//Do some inserts...
reinterpret_cast<wrapper<typename my_map::value_type>&>(*m.find(10)).get_second() = 1.0;
我希望允许客户端代码访问地图的条目,而无需知道由地图return编辑的对。我还想编写一个自定义的前向迭代器,因此我需要 return 对条目的引用。将对这对的引用转换为对作为包装器的 class 的引用会被认为是危险的吗?
是否有更好的方法来完成此任务?
所以你可以清理它,但我不建议这样做:
#include <unordered_map>
#include <iostream>
using namespace std;
template <class Key, class Value>
class wrapper
{
public:
explicit wrapper(std::pair<const Key, Value>& kvp)
: _key{kvp.first}
, _value{kvp.second}
{}
const Key& key() const { return _key; }
Value& value() { return _value; }
private:
const Key& _key;
Value& _value;
};
int main()
{
unordered_map<int,int> m;
m[1] = 1;
m[3] = 3;
auto it = m.find(1);
wrapper w{*it};
w.value() = 30;
std::cout << w.key() << " -> " << w.value() << '\n';
}
以上内容有效地向 class 的用户隐藏了 pair
。它不处理异常(例如 find()
返回 end()
),也不保证生命周期。它比您拥有的要好一些,因为它不需要 reinterpret_cast
到不相关的类型。
但是,map
、unordered_map
、set
等将返回的迭代器成对存储只是库的一部分——它是规范形式,我看不到保护人们免受它的好处。
这绝对是未定义的行为。
认真重新考虑您的优先事项。
形式的一些免费函数
const my_map::key_type & MeaningfulNameHere(my_map::reference)
会给你有意义的名字大有帮助。
如果您必须用不同的名称包装标准库,只需使用非显式构造函数并存储引用即可。
template <typename Map>
class entry final
{
private:
typename Map::reference ref;
public:
entry(Map::reference ref) : ref(ref) {}
const typename Map::key_type & key()
{
return ref.first;
}
typename Map::mapped_type & value()
{
return ref.second;
}
};
如果您确实需要 迭代器取消对entry
的引用,您可以。但是您可以从 Map::iterator::operator*
返回的 Map::reference
中隐式实例化 entry
,您不需要自定义迭代器。
template <typename Map>
class entry_iterator
{
private:
typename Map::iterator it;
entry<Map> entry;
public:
entry<Map>& operator*() { return entry; }
entry_iterator operator++() { ++it; entry = *it; return *this; }
// etc
}
我正在编写一些包装 std::unordered_map 类型的 C++ 代码,我想在其中隐藏基础类型并将其呈现为另一种类型。更具体地说,我想用另一种类型包装 std::unordered_map 中的 std::pair。为了争论,让我们假设包装看起来像这样......
template <typename ActualT >
class wrapper final
{
private:
ActualT actual_;
public:
//Some constructors...
typename ActualT::first_type & get_first()
{
return actual_.first;
}
typename ActualT::second_type & get_second()
{
return actual_.second;
}
};
我的理由是,由于包装器 class 只有一个成员是它所包装的确切类型,将引用从原始类型转换为包装器类型应该没问题,但类型兼容性for structs 声明成员应该具有相同的类型和名称以使类型兼容。以这种方式使用类型双关是否会导致未定义的行为或对齐问题?
using my_map = std::unordered_map < int, int >;
my_map m;
//Do some inserts...
reinterpret_cast<wrapper<typename my_map::value_type>&>(*m.find(10)).get_second() = 1.0;
我希望允许客户端代码访问地图的条目,而无需知道由地图return编辑的对。我还想编写一个自定义的前向迭代器,因此我需要 return 对条目的引用。将对这对的引用转换为对作为包装器的 class 的引用会被认为是危险的吗?
是否有更好的方法来完成此任务?
所以你可以清理它,但我不建议这样做:
#include <unordered_map>
#include <iostream>
using namespace std;
template <class Key, class Value>
class wrapper
{
public:
explicit wrapper(std::pair<const Key, Value>& kvp)
: _key{kvp.first}
, _value{kvp.second}
{}
const Key& key() const { return _key; }
Value& value() { return _value; }
private:
const Key& _key;
Value& _value;
};
int main()
{
unordered_map<int,int> m;
m[1] = 1;
m[3] = 3;
auto it = m.find(1);
wrapper w{*it};
w.value() = 30;
std::cout << w.key() << " -> " << w.value() << '\n';
}
以上内容有效地向 class 的用户隐藏了 pair
。它不处理异常(例如 find()
返回 end()
),也不保证生命周期。它比您拥有的要好一些,因为它不需要 reinterpret_cast
到不相关的类型。
但是,map
、unordered_map
、set
等将返回的迭代器成对存储只是库的一部分——它是规范形式,我看不到保护人们免受它的好处。
这绝对是未定义的行为。
认真重新考虑您的优先事项。
形式的一些免费函数
const my_map::key_type & MeaningfulNameHere(my_map::reference)
会给你有意义的名字大有帮助。
如果您必须用不同的名称包装标准库,只需使用非显式构造函数并存储引用即可。
template <typename Map>
class entry final
{
private:
typename Map::reference ref;
public:
entry(Map::reference ref) : ref(ref) {}
const typename Map::key_type & key()
{
return ref.first;
}
typename Map::mapped_type & value()
{
return ref.second;
}
};
如果您确实需要 迭代器取消对entry
的引用,您可以。但是您可以从 Map::iterator::operator*
返回的 Map::reference
中隐式实例化 entry
,您不需要自定义迭代器。
template <typename Map>
class entry_iterator
{
private:
typename Map::iterator it;
entry<Map> entry;
public:
entry<Map>& operator*() { return entry; }
entry_iterator operator++() { ++it; entry = *it; return *this; }
// etc
}