实现指针元组的深度复制
Implementing deep copying of tuple of pointers
如果我错了,请纠正我,但在运行时
std::tuple<double*, bool*> t(new double(3.5), new bool(true));
print_tuple(t);
std::tuple<double*, bool*> n = t;
print_tuple(n);
我得到
std::get<0>(t) = 0x1f13d0
std::get<1>(t) = 0x1f13b0
std::get<0>(n) = 0x1f13d0
std::get<1>(n) = 0x1f13b0
这意味着元组中的指针只是浅层复制的,对吧?因此,我编写了一个简单的实用程序,用于深度复制元组中作为指针的所有元素:
template <std::size_t N, typename Tuple>
std::enable_if_t<std::is_pointer<std::tuple_element_t<N, Tuple>>::value> assign (Tuple& tuple, const Tuple& other) {
std::get<N>(tuple) = new std::remove_pointer_t<std::tuple_element_t<N, Tuple>>(*std::get<N>(other));
}
template <std::size_t N, typename Tuple>
std::enable_if_t<!std::is_pointer<std::tuple_element_t<N, Tuple>>::value> assign (Tuple& tuple, const Tuple& other) {
std::get<N>(tuple) = std::get<N>(other);
}
template <typename Tuple, std::size_t... Is>
Tuple deep_copy_impl (const Tuple& other, std::index_sequence<Is...>) {
Tuple tuple = {};
const int a[] = {(assign<Is>(tuple, other), 0)...};
static_cast<void>(a);
return tuple;
}
template <typename Tuple>
Tuple deep_copy (const Tuple& other) {
return deep_copy_impl(other, std::make_index_sequence<std::tuple_size<Tuple>::value>{});
}
对于上面的例子来说,这似乎很好,但当我尝试使用定义的元组tup
时
std::tuple<double*, bool*> t(new double(3.5), new bool(true));
std::tuple<int*, std::tuple<double*, bool*>*, char> tup(new int(5), &t, 'a');
我得到了元组指针的深层副本,但元组指针中的指针再次被浅层复制。我希望这些指针也能被深入复制。如何为任意数量的嵌套指针元组修复此问题?以下是我的测试结果:
#include <iostream>
#include <type_traits>
#include <utility>
#include <tuple>
template <std::size_t N, typename Tuple>
std::enable_if_t<std::is_pointer<std::tuple_element_t<N, Tuple>>::value> assign (Tuple& tuple, const Tuple& other) {
std::get<N>(tuple) = new std::remove_pointer_t<std::tuple_element_t<N, Tuple>>(*std::get<N>(other));
}
template <std::size_t N, typename Tuple>
std::enable_if_t<!std::is_pointer<std::tuple_element_t<N, Tuple>>::value> assign (Tuple& tuple, const Tuple& other) {
std::get<N>(tuple) = std::get<N>(other);
}
template <typename Tuple, std::size_t... Is>
Tuple deep_copy_impl (const Tuple& other, std::index_sequence<Is...>) {
Tuple tuple = {};
const int a[] = {(assign<Is>(tuple, other), 0)...};
static_cast<void>(a);
return tuple;
}
template <typename Tuple>
Tuple deep_copy (const Tuple& other) {
return deep_copy_impl(other, std::make_index_sequence<std::tuple_size<Tuple>::value>{});
}
// Testing
template <typename Tuple, std::size_t... Is>
std::ostream& print_tuple_impl (const Tuple& tuple, std::ostream& os, std::index_sequence<Is...>) {
const int a[] = {(os << "std::get<" << Is << ">(tuple) = " << std::get<Is>(tuple) << 'n', 0)...};
static_cast<void>(a);
return os;
}
template <typename Tuple>
std::ostream& print_tuple (const Tuple& tuple, std::ostream& os = std::cout) {
return print_tuple_impl (tuple, os, std::make_index_sequence<std::tuple_size<Tuple>::value>{});
}
int main() {
std::tuple<double*, bool*> t(new double(3.5), new bool(true));
print_tuple(t);
std::tuple<double*, bool*> n = t;
print_tuple(n);
std::cout << "Above is shallow copying only.nn";
std::tuple<int*, std::tuple<double*, bool*>*, char> tup(new int(5), &t, 'a');
print_tuple(tup);
std::tuple<int*, std::tuple<double*, bool*>*, char> q = deep_copy(tup);
print_tuple(q);
std::cout << "nAbove seems like a deep copy, but look at this:n";
print_tuple(*std::get<1>(tup));
print_tuple(*std::get<1>(q));
}
输出:
std::get<0>(tuple) = 0x1f13d0
std::get<1>(tuple) = 0x1f13b0
std::get<0>(tuple) = 0x1f13d0
std::get<1>(tuple) = 0x1f13b0
Above is shallow copying only.
std::get<0>(tuple) = 0x1f13f0
std::get<1>(tuple) = 0x72fe10
std::get<2>(tuple) = a
std::get<0>(tuple) = 0x1f1410
std::get<1>(tuple) = 0x1f1430
std::get<2>(tuple) = a
Above seems like a deep copy, but look at this:
std::get<0>(tuple) = 0x1f13d0
std::get<1>(tuple) = 0x1f13b0
std::get<0>(tuple) = 0x1f13d0
std::get<1>(tuple) = 0x1f13b0
template<class T> T deep_copy(const T& t);
template<class T> T* deep_copy(T* tp);
template<class... Ts> std::tuple<Ts...> deep_copy(const std::tuple<Ts...>&);
template<class T>
T deep_copy(const T& t) { return t; }
template<class T>
T* deep_copy(T* tp) { return new T(deep_copy(*tp)); }
template<class... Ts, size_t... Is>
std::tuple<Ts...> deep_copy_impl(const std::tuple<Ts...>& t, std::index_sequence<Is...>) {
return std::tuple<Ts...>{deep_copy(std::get<Is>(t))... };
}
template<class... Ts>
std::tuple<Ts...> deep_copy(const std::tuple<Ts...>& t) {
return deep_copy_impl(tuple, std::index_sequence_for<Ts...>());
}
将T.C.的想法扩展到STL容器:
#include <iostream>
#include <type_traits>
#include <utility>
#include <tuple>
#include <vector>
#include <set>
template <typename T>
using void_t = void;
template <typename T, typename = void>
struct has_emplace_back : std::false_type {};
template <typename T>
struct has_emplace_back<T, void_t<decltype(std::declval<T>().emplace_back(std::declval<typename T::value_type>()))>> : std::true_type {};
template <typename T, typename = void>
struct has_emplace : std::false_type {};
template <typename T>
struct has_emplace<T, void_t<decltype(std::declval<T>().emplace(std::declval<typename T::value_type>()))>> : std::true_type {};
// etc... for other container types.
template <typename T>
struct is_stl_container : std::integral_constant<bool, has_emplace_back<T>::value || has_emplace<T>::value> {};
template <typename Container> std::enable_if_t<has_emplace_back<Container>::value, Container> deep_copy (const Container&);
template <typename Container> std::enable_if_t<has_emplace<Container>::value, Container> deep_copy (const Container&);
template <typename... Ts> std::tuple<Ts...> deep_copy (const std::tuple<Ts...>&); // This forward declarations, though not needed to compile, is needed for the nested deep copying to work correctly.
template <typename T>
std::enable_if_t<!is_stl_container<T>::value, T> deep_copy (const T& t) {
return t;
}
template <typename T>
T* deep_copy (T* t) {
return new T(deep_copy(*t)); // Note that since T's copy constructor is called here, then if T is a custom class that has its own custom copy constructor that carries out deep copying, then t's pointer data members are also deep copied.
}
template <typename... Ts, std::size_t... Is>
std::tuple<Ts...> deep_copy_impl (const std::tuple<Ts...>& tuple, std::index_sequence<Is...>) {
return std::tuple<Ts...>{ deep_copy(std::get<Is>(tuple))... };
}
template <typename... Ts>
std::tuple<Ts...> deep_copy (const std::tuple<Ts...>& tuple) {
return deep_copy_impl(tuple, std::index_sequence_for<Ts...>{});
}
template <typename Container>
std::enable_if_t<has_emplace_back<Container>::value, Container> deep_copy (const Container& c) {
Container container;
for (const typename Container::value_type& t : c)
container.emplace_back(deep_copy(t));
return container;
}
template <typename Container>
std::enable_if_t<has_emplace<Container>::value, Container> deep_copy (const Container& c) {
Container container;
for (const typename Container::value_type& t : c)
container.emplace(deep_copy(t));
return container;
}
// Testing
template <typename Tuple, std::size_t... Is>
std::ostream& print_tuple_impl (const Tuple& tuple, std::ostream& os, std::index_sequence<Is...>) {
const int a[] = {(os << "std::get<" << Is << ">(tuple) = " << std::get<Is>(tuple) << 'n', 0)...};
static_cast<void>(a);
return os;
}
template <typename Tuple>
std::ostream& print_tuple (const Tuple& tuple, std::ostream& os = std::cout) {
return print_tuple_impl (tuple, os, std::make_index_sequence<std::tuple_size<Tuple>::value>{});
}
int main() {
std::tuple<double*, bool*> t(new double(3.5), new bool(true));
print_tuple(t);
std::tuple<double*, bool*> n = t;
print_tuple(n);
std::cout << "Above is shallow copying only.nn";
std::tuple<int*, std::tuple<double*, bool*>*, char> tup(new int(5), &t, 'a');
print_tuple(tup);
std::tuple<int*, std::tuple<double*, bool*>*, char> q = deep_copy(tup);
print_tuple(q);
std::cout << "nAbove and below show that we have full deep copying:n";
print_tuple(*std::get<1>(tup));
print_tuple(*std::get<1>(q));
std::cout << "nDeep copy of a vector of pointers:n";
std::vector<int*> v = {new int(5), new int(2), new int(8)};
for (int* x : v) std::cout << x << ' '; std::cout << 'n';
std::vector<int*> u = deep_copy(v);
for (int* x : u) std::cout << x << ' '; std::cout << 'n';
std::cout << "nDeep copy of a set of pointers:n";
std::set<int*> s = {new int(5), new int(2), new int(8)};
for (int* x : s) std::cout << x << ' '; std::cout << 'n';
std::set<int*> ss = deep_copy(s);
for (int* x : ss) std::cout << x << ' '; std::cout << 'n';
}
输出:
std::get<0>(tuple) = 0x8513d0
std::get<1>(tuple) = 0x8513b0
std::get<0>(tuple) = 0x8513d0
std::get<1>(tuple) = 0x8513b0
Above is shallow copying only.
std::get<0>(tuple) = 0x8513f0
std::get<1>(tuple) = 0x72fd70
std::get<2>(tuple) = a
std::get<0>(tuple) = 0x851410
std::get<1>(tuple) = 0x851470
std::get<2>(tuple) = a
Above and below show that we have full deep copying:
std::get<0>(tuple) = 0x8513d0
std::get<1>(tuple) = 0x8513b0
std::get<0>(tuple) = 0x851430
std::get<1>(tuple) = 0x851450
Deep copy of a vector of pointers:
0x851490 0x8514b0 0x8514d0
0x851510 0x851550 0x851530
Deep copy of a set of pointers:
0x851570 0x8515c0 0x8515e0
0x851690 0x851800 0x851870
相关文章:
- C++17复制构造函数,在std::unordereded_map上进行深度复制
- C++尝试深度复制唯一指针时出现内存访问冲突
- 在 c++ 中使用深度复制的运算符重载
- 如何深度复制链表对象指针
- 我有两棵二叉树.我想在不更改输入树的情况下深度复制两个二叉树的结果
- 如何将结构深度复制到向量的每个元素
- 我需要做一个深度复制,我是否正确使用了我的复制构造函数?
- 是否可以在不显式迭代每个元素的情况下深度复制指针容器?
- 如何深度复制unique_ptr向量
- 二叉搜索树 深度复制和取消引用
- 链表的这个别名运算符是否会产生深度复制
- 有没有一种 stl 方法来执行指针向量的深度复制
- cv::P oint3f 赋值运算符是否执行"深度"复制?
- Qt:通过深度复制访问列表中的数据结构是否应该比通过指针访问它慢得多
- 深度复制包含引用成员(C++)的结构
- 如何将“char *”深度复制到std::stringstream
- 如何在双向链表上执行深度复制
- 在复制构造函数中执行深度复制
- 深度复制cv::垫子替代品,哪个更好?
- 在 C/C++ 中使用 ProtoBuf 进行深度复制