跟我学c++中级篇——手动实现类tuple

于 2024-03-03 17:59:32 发布
阅读量394 收藏 6
点赞数 3
CC 4.0 BY-SA版权
分类专栏： C++ C++11 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/fpcc/article/details/136435347
本文详细描述了一个自定义类Tuple的实现过程，通过模板和变参类来创建类指针，并展示了如何获取并操作内部对象，尽管最初设想采用多态和静态容器，但因模板匹配问题最终选择了动态生成和索引控制的方案，留待后续优化。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一、问题

在某个场景下需要实现一个类似于Tuple的类，主要是用于类指针的创建。直接使用Tuple其实是可以的，但一开始没有想清楚，所以后来绕了一圈儿后还是回到了类Tuple的实现。下面把这个实现的过程简要说明分析一下。

二、实现过程

实现的过程其实并不复杂，利用一个变参模板类展开即可：

template <typename... T> class CmdObj;
template <> class CmdObj<> {};
template <typename T, typename... N> class CmdObj<T, N...> : public CmdObj<N...> {
public:
  using Base = CmdObj<N...>;
  CmdObj() : Base() {
    T *ptr = new T();
    if (ptr != nullptr) {
      m_t = ptr;
    }
  }
  ~CmdObj() = default;

public:
  Base *getBase() { return this; }

public:
  T *m_t;
};

代码很简单，其实就是一个变量模板类的实现。

三、获取对象和分析

在创建完成对象指针后，就可以获取其内部的指针了：

template <int id, typename T> class CmdObjElement {
public:
  using Type = typename CmdObjElement<id - 1, typename T::Base>::Type;
};
template <typename T> class CmdObjElement<0, T> {
public:
  using Type = T;
};
template <int id, typename T> constexpr auto &GetCmdObj(T &t) {
  using Type = typename CmdObjElement<id, T>::Type;
  return static_cast<Type &>(t).m_t;
}

将上面的两部分代码合并在一起，写一个例程，然后编译：

#include <iostream>
#include <memory>
#include <tuple>
#include <type_traits>

template<typename ... T>
class CmdObj;
/* First instantiated from: insights.cpp:11 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
class CmdObj<B, C, D> : public CmdObj<C, D>
{
  
  public: 
  using Base = CmdObj<C, D>;
  inline CmdObj()
  : CmdObj<C, D>()
  {
    B * ptr = new B();
    if(ptr != nullptr) {
      this->m_t = ptr;
    } 
    
  }
  
  inline ~CmdObj() noexcept = default;
  
  public: 
  inline CmdObj<C, D> * getBase();
  
  
  public: 
  B * m_t;
};

#endif
/* First instantiated from: insights.cpp:11 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
class CmdObj<C, D> : public CmdObj<D>
{
  
  public: 
  using Base = CmdObj<D>;
  inline CmdObj()
  : CmdObj<D>()
  {
    C * ptr = new C();
    if(ptr != nullptr) {
      this->m_t = ptr;
    } 
    
  }
  
  inline ~CmdObj() noexcept = default;
  
  public: 
  inline CmdObj<D> * getBase();
  
  
  public: 
  C * m_t;
};

#endif
/* First instantiated from: insights.cpp:11 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
class CmdObj<D> : public CmdObj<>
{
  
  public: 
  using Base = CmdObj<>;
  inline CmdObj()
  : CmdObj<>()
  {
    D * ptr = new D();
    if(ptr != nullptr) {
      this->m_t = ptr;
    } 
    
  }
  
  inline ~CmdObj() noexcept = default;
  
  public: 
  inline CmdObj<> * getBase();
  
  
  public: 
  D * m_t;
};

#endif
/* First instantiated from: insights.cpp:57 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
class CmdObj<A, B, C, D> : public CmdObj<B, C, D>
{
  
  public: 
  using Base = CmdObj<B, C, D>;
  inline CmdObj()
  : CmdObj<B, C, D>()
  {
    A * ptr = new A();
    if(ptr != nullptr) {
      this->m_t = ptr;
    } 
    
  }
  
  inline ~CmdObj() noexcept = default;
  
  public: 
  inline CmdObj<B, C, D> * getBase();
  
  
  public: 
  A * m_t;
};

#endif

template<>
class CmdObj<>
{
  public: 
};


template<typename T, typename ... N>
class CmdObj<T, N...> : public CmdObj<N...>
{
  
  public: 
  using Base = CmdObj<N...>;
  inline CmdObj()
  : Base{}
  {
    T * ptr = new T{};
    if(ptr != nullptr) {
      this->m_t = ptr;
    } 
    
  }
  
  inline ~CmdObj() = default;
  
  public: 
  inline Base * getBase()
  {
    return this;
  }
  
  
  public: 
  T * m_t;
};


template<int id, typename T>
class CmdObjElement
{
  
  public: 
  using Type = typename CmdObjElement<id - 1, typename T::Base>::Type;
};

/* First instantiated from: insights.cpp:30 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
class CmdObjElement<0, CmdObj<B, C, D> >
{
  
  public: 
  using Type = CmdObj<B, C, D>;
};

#endif
/* First instantiated from: insights.cpp:30 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
class CmdObjElement<1, CmdObj<B, C, D> >
{
  
  public: 
  using Type = CmdObjElement<0, CmdObj<C, D> >::CmdObj<C, D>;
};

#endif
/* First instantiated from: insights.cpp:30 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
class CmdObjElement<0, CmdObj<C, D> >
{
  
  public: 
  using Type = CmdObj<C, D>;
};

#endif
/* First instantiated from: insights.cpp:30 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
class CmdObjElement<2, CmdObj<B, C, D> >
{
  
  public: 
  using Type = CmdObjElement<0, CmdObj<D> >::CmdObj<D>;
};

#endif
/* First instantiated from: insights.cpp:30 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
class CmdObjElement<1, CmdObj<C, D> >
{
  
  public: 
  using Type = CmdObjElement<0, CmdObj<D> >::CmdObj<D>;
};

#endif
/* First instantiated from: insights.cpp:30 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
class CmdObjElement<0, CmdObj<D> >
{
  
  public: 
  using Type = CmdObj<D>;
};

#endif
/* First instantiated from: insights.cpp:37 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
class CmdObjElement<0, CmdObj<A, B, C, D> >
{
  
  public: 
  using Type = CmdObj<A, B, C, D>;
};

#endif
/* First instantiated from: insights.cpp:37 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
class CmdObjElement<1, CmdObj<A, B, C, D> >
{
  
  public: 
  using Type = CmdObjElement<0, CmdObj<B, C, D> >::CmdObj<B, C, D>;
};

#endif
/* First instantiated from: insights.cpp:37 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
class CmdObjElement<2, CmdObj<A, B, C, D> >
{
  
  public: 
  using Type = CmdObjElement<0, CmdObj<C, D> >::CmdObj<C, D>;
};

#endif
/* First instantiated from: insights.cpp:37 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
class CmdObjElement<3, CmdObj<A, B, C, D> >
{
  
  public: 
  using Type = CmdObjElement<0, CmdObj<D> >::CmdObj<D>;
};

#endif

template<typename T>
class CmdObjElement<0, T>
{
  
  public: 
  using Type = T;
};


template<int id, typename T>
inline constexpr auto & GetCmdObj(T & t)
{
  using Type = typename CmdObjElement<id, T>::Type;
  return static_cast<Type &>(t).m_t;
}


#ifdef INSIGHTS_USE_TEMPLATE
template<>
inline constexpr A *& GetCmdObj<0, CmdObj<A, B, C, D> >(CmdObj<A, B, C, D> & t)
{
  using Type = CmdObjElement<0, CmdObj<A, B, C, D> >::CmdObj<A, B, C, D>;
  return static_cast<CmdObjElement<0, CmdObj<A, B, C, D> >::CmdObj<A, B, C, D> &>(t).m_t;
}
#endif


#ifdef INSIGHTS_USE_TEMPLATE
template<>
inline constexpr B *& GetCmdObj<1, CmdObj<A, B, C, D> >(CmdObj<A, B, C, D> & t)
{
  using Type = CmdObjElement<0, CmdObj<B, C, D> >::CmdObj<B, C, D>;
  return static_cast<CmdObjElement<0, CmdObj<B, C, D> >::CmdObj<B, C, D> &>(t).m_t;
}
#endif


#ifdef INSIGHTS_USE_TEMPLATE
template<>
inline constexpr C *& GetCmdObj<2, CmdObj<A, B, C, D> >(CmdObj<A, B, C, D> & t)
{
  using Type = CmdObjElement<0, CmdObj<C, D> >::CmdObj<C, D>;
  return static_cast<CmdObjElement<0, CmdObj<C, D> >::CmdObj<C, D> &>(t).m_t;
}
#endif


#ifdef INSIGHTS_USE_TEMPLATE
template<>
inline constexpr D *& GetCmdObj<3, CmdObj<A, B, C, D> >(CmdObj<A, B, C, D> & t)
{
  using Type = CmdObjElement<0, CmdObj<D> >::CmdObj<D>;
  return static_cast<CmdObjElement<0, CmdObj<D> >::CmdObj<D> &>(t).m_t;
}
#endif



struct A
{
  inline void test()
  {
    std::operator<<(std::cout, "this is A!").operator<<(std::endl);
  }
  
};


struct B
{
  inline void test()
  {
    std::operator<<(std::cout, "this is b!").operator<<(std::endl);
  }
  
};


struct C
{
  inline void test()
  {
    std::operator<<(std::cout, "this is c!").operator<<(std::endl);
  }
  
};


struct D
{
  inline void test()
  {
    std::operator<<(std::cout, "this is d!").operator<<(std::endl);
  }
  
};


void Display()
{
  std::shared_ptr<CmdObj<A, B, C, D> > x = std::make_shared<CmdObj<A, B, C, D> >();
  A * xA = GetCmdObj<0>(static_cast<const std::__shared_ptr_access<CmdObj<A, B, C, D>, 2, false, false>&>(x).operator*());
  xA->test();
  B * xB = GetCmdObj<1>(static_cast<const std::__shared_ptr_access<CmdObj<A, B, C, D>, 2, false, false>&>(x).operator*());
  xB->test();
  C * xC = GetCmdObj<2>(static_cast<const std::__shared_ptr_access<CmdObj<A, B, C, D>, 2, false, false>&>(x).operator*());
  xC->test();
  D * xD = GetCmdObj<3>(static_cast<const std::__shared_ptr_access<CmdObj<A, B, C, D>, 2, false, false>&>(x).operator*());
  xD->test();
}

int main()
{
  Display();
  return 0;
}

有一个好工具就是好用啊，分析代码也方便太多了。有了编译前后的代码比较，再结合模板的相关知识，应该是一目了然了。

四、总结

到最后的实现仍然是使用了类似std::tuple的实现，通过索引ID来获取不同类型的具体的指针。其实最初是想的通过一个基类形成的静态容器返回然后通过多态来达到对不同类型的控制。可惜的是模板的匹配总是无法通过，只好改成一个动态生成动态获取的过程。后来又想通过在遍历的时候儿拿到对象指针而非固定写到指定的索引上，毕竟这样就无法修改对象生成的顺序了。可又无法解决不同对象回传的问题（通过基类返回直接就崩溃了）。故而目前只能还是先使用这种索引控制来得到具体的对象指针，以后有机会再优化它。

c++tuple
weixin_39291964的博客
03-09 454
C++中的tuple是一个非常灵活和强大的工具，它允许你在一个单一的变量中存储不同类型的值。通过std::get和结构化绑定，你可以方便地访问和操作这些值。此外，tuple还支持比较操作，使得它们可以用在排序和搜索算法中。
C++ tuple(元组) 的实现/原理
extratorsion的博客
07-30 4645
C++最新中引入了 tuple， 可以定义任意多个类型的对象的组合, 关于C++ tuple 的实现，可以参照如下代码实例来理解tuple实现的原理。 #include &lt;iostream&gt; using namespace std; template&lt;typename... Values&gt;class Tuple; template&lt;&gt;class Tupl...
c++ 11 tuple实现
qq_26661927的专栏
09-19 745
// =============== tuple 存储不同类型的数据 ======================// template<typename... TList> class tuple; template<> class tuple<>{}; template<typename T, typename... TList> class tuple<T, TList...> : privat
C++模板实践：tuple
大耳朵鱼的博客
07-29 466
C++模板实践：tuple 本文的目的是手工实现std::tuple类型，也是就是元组类型。它可以看作是一种没有成员名称的结构体，首先看一看它的用法： #include <tuple> #include <string> #include <iostream> using namespace std; int main() { // 一个二元组 tuple<int, float> t1 {1, 2.0f}; // 一个三元组 tuple<in
C++ 之 tuple
761899457@qq.com
09-30 858
tuple其实就可以理解成pair的拓展。
C++代码片段（五）tuple的实现
一个程序渣渣的小后院
06-08 2142
元组tuple是多类型的集合，可以当做升级版的pair来用。因为tuple可以保存多个任意类型的值，导致不能够在一个类里面保存所有的数据，所以采用每一层保存一个数据的方法实现 实现tuple template &amp;lt;typename... Args&amp;gt; class tuple { }; /* 每一层保存一个T类型的数据 */ template &amp;lt;typename T,...
【Python从入门到精通】（二十八）五万六千字对Python基础知识做一个了结吧【值得收藏】
m0_67403013的博客
07-31 3459
列表作为Python序列类型中的一种，其也是用于存储多个元素的一块内存空间，这些元素按照一定的顺序排列。element1~elementn表示列表中的元素，元素的数据格式没有限制，只要是Python支持的数据格式都可以往里面方。同时因为列表支持自动扩容，所以它可变序列，即可以动态的修改列表，即可以修改，新增，删除列表元素。看个爽图吧！说完了列表，接着让我们来看看另外一个重要的序列–元组（tuple），和列表类似，元组也是由一系列按特定书序排序的元素组成，与列表最重要的区别是，def函数名（参数列表）...
[转]高负载并发网站架构分析
热门推荐
bluehire的专栏
12-23 2万+
由于自己正在做一个高性能大用户量的论坛程序，对高性能高并发服务器架构比较感兴趣，于是在网上收集了不少这方面的资料和大家分享。希望能和大家交流 msn: defender_ios@hotmail.com ——————————————————————————————————————— ? 初创网站与开源软件 6 ? 谈谈大型高负载网站服务器的优化心得! 8 ? Lighttpd+Squid+Apach
《数据库系统概论》学习笔记
StaffPencil的博客
01-29 2596
本学习笔记的主要用途，是来回顾数据库的一些基本理论知识和SQL语句。学习笔记的主要参考文献，为王珊著的《数据库系统概论》（第5版，2014）和教育部考试中心出版的《全国计算机等级考试三级教程——数据库技术》（2022年版），其中以王珊著的《数据库系统概论》为主要架构。其他具体内容可能会涉及到的其他资料和文章，我会附在相应小节的最后。相对应地，我也会选择并写出一些自己实践过程中遇到的bug和问题，并附带相应的解决方法。首次撰写博客，如有不足之处还望批评指正。
C++使用tuple，实现多返回值
小孔明的专栏
07-25 448
C++使用tuple，实现多返回值。
tuple:C ++ 11中的简单元组实现
04-01
元组 C ++ 11中的简单元组实现 实现元组的新方法
C++ tuple元组的基本用法(总结)
08-18
主要介绍了C++ tuple元组的基本用法(总结)，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
类似Boost中Tuple的实现
10-23
类似Boost中Tuple的实现 自己编写的 请支持原创
C++ STL 内 std::{bind/tuple/function} 简单实现
12-20
基本逻辑思考 首先是实现 function，这个比较简单，重载 operator() 就好，这里只实现对函数指针的包装 其次是实现 tuple，这个会比较绕，通过模板取第一个参数，然后用剩下的参数继续生成  tuple并继承，是一种递归的思想 有了 tuple 就要有 get()，这个就更比较绕了，首先是需要类似的方式实现获得 tuple 的值类型与元组类型，然后通过强制类型转换，获取对应的层级的 value 接下来是 bind，首先要解决的就是如何保存创建时的参数列表，这里就用到 tuple 来保存了 奇技淫巧还是运行函数时取相应的元组的对应位置的值，还是类似的方式，通过特化模板，公式是 
C++(11)：tuple
风静如云的博客
11-07 1022
C++11引入了tuple(元组)，tuple可以被看作是一个模板花的结构体，他可以在定义时包含任意类型任意数量的成员。可以通过tuple_cat，将多个tuple拼接为一个。
【c++11】tuple
永无止境
01-13 1077
参考：http://blog.youkuaiyun.com/aspnet_lyc/article/details/30980465 我们在C++中都用过pair.pair是一种模板类型，其中包含两个数据值，两个数据的类型可以不同.pair可以使用make_pair构造 [cpp] view plaincopyprint? pairint, string> p = make_pai
C++——tuple类型
JAN6055的博客
03-14 4486
tuple类型的简单介绍
C++11 tuple
ccf19881030的专栏
04-21 927
C++11 tuple(元组) tuple是C++11中引入的新类型，中文翻译就是元组。元组是一个能够容纳元素集合的对象。 每个元素可以具有不同的类型。类模板std :: tuple是固定大小的异构值集合。具体可以参考tuple-cppreference.com和tuple-cplusplus.com中的描述，并且提供了一些示例程序。 其中，tuple-cplusplus.com/中提供的示例程序...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值