自动化C++程序设计---基础篇_分析C++重载函数(2)--分析函数参数的种类

于 2007-10-23 21:55:00 发布
阅读量1.8k 收藏 2
点赞数 1
分类专栏： C++基础 模板元程序 软件架构 文章标签： c++ class struct function filter border
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pandaxcl/article/details/1840317
版权
书名: 《自动化C++程序设计》
作者: 熊春雷
网站: http://www.autodev.net
Blog: http://blog.csdn.net/pandaxcl
EMail: pandaxcl@163.com
昵称: pandaxcl，开心
QQ: 56637059
MSN: pandaxcl@163.com
版本: 0.01 于2007/09/25
目标: 所有C++爱好者
版权: 本文的版权归熊春雷所有
代码库: autocxx（在论坛下载）

Warning

  1. 本文由熊春雷所写，绝对保证原创，在此特别严肃声明。本人简介：熊春 雷，男，1980年出生于湖北钟祥；七岁随父迁往宜昌开始学生生涯，小学和初中在 湖北宜昌樟村坪镇职工子弟学校就读；1996年考上宜昌县高中，开始三年的高中生 活；1999-2003就读于湖北大学物理系；2003-2006就读于武汉大学物理系。现就职 于盛大网络：）

  2. 绝对不能容忍他人说本文为他所写以及其他的侵权行为。一旦发现，一定 尽本人最大的能力以法律的形式严追到底，决不妥协。

  3. 引用本文，要保证本文的完整性，不可以删除此处的声明，并且务必注明出处。

Tip

  1. 本文编写的所有代码可以用于任何用途（包括商业用途）。

  2. 用于商业用途的需要在最后发布的软件中声明借鉴了本文的思想。具体事 宜可以协商解决，（代码决不收取任何费用）。

  3. 其他事项可以和我联系，包括技术讨论等等:)或者直接登陆网站论坛： http://www.autodev.net

Note

  1. 本文受到了《C++设计新思维》和《产生式编程》两本书的影响，同时也查阅了大 量的资料，从Loki库和Boost库中也吸收了不少营养，特此感谢之。

  2. 本文由于处于原创阶段，难免会出现各种各样的错误。代码出现错误的可能性非常 小（本来想说为零的），因为文档和代码是严格同步的，这是由VST文本的include 所保证的，代码都是测试成功之后才发布的。

  3. 本文所编写的代码，经过了VC2005编译器和g++编译器的测试，并且都通过了。

  4. 本文还没有彻底完成，算是一个初级版本，未来还将继续完善。暂时发布出来是为 了预知读者群有多少，读者越多，我的成就感越强，写作的时候也会更有动力:)

  5. 本文还会继续完善，欢迎各位读者的批评指正，也接受各种各样的建议，在权衡之 后以决定是否加入本书。

  6. 本书还没有最终完成，还会不断的进行完善，更新之后的内容将会发表于我的 网站或我的博客。所以还需要读者多多关心本文的进展:)

Contents

分析函数参数的种类

目的

本文的目的是根据给出的重载函数（on），分析出在可能的候选函数参数类型中有哪些类 型被使用了。关于这一点功能的实现还需要分四个步骤来实现：

  1. 先实现一个参数的重载函数的分析

  2. 再利用和一个参数的重载分析一样的方法实现两个参数的重载函数的分析

  3. 将2中的方法扩展到两个参数的自动化分析

  4. 对于多于两个参数的自动化分析采用3中的方法实现之

先实现一个参数的重载函数的分析

 kind<9> on(...);  char on(n<1>);  char on(n<3>);  char on(n<4>);  template<class ENV,class A1>struct FILTER  {      typedef n<sizeof(on(A1()))!=sizeof(kind<9>)> type;  };   // 把所有的可能类型列举出来  typedef mkps<n<1>,n<2>,n<3>,n<4>,n<5>,n<6>,n<7>,n<8>,n<9> >::type EPS;  typedef filter<EPS,nil,FILTER>::type USED;  typedef mkps<n<1>,n<3>,n<4> >::type EXPECTED;  static_assert_same<EXPECTED,USED>();

从上面的代码可以看出，对于一个参数的情况，仅仅用简单的过滤就可以了。此外，上 面的代码处理的是一个全局域中的函数（on）的参数种类问题！实际上这种分析全局域 中的函数参数种类的情况并不多见，常见的是分析类域中的函数参数种类的问题！所以 本文的重点就放在分析类域中的函数参数种类的问题上面： 

 struct A// 用类域把函数封装起来  {      kind<9> on(...);      char on(n<1>);      char on(n<3>);      char on(n<4>);  };  template<class ENV,class H>struct FILTER;// filter需要的格式  template<class Type,class Kind,class H>struct FILTER<p<Type,p<Kind> >,H>  {      enum{i=sizeof(Type().on(H()))!=sizeof(Kind)};      typedef n<i> type;  };   // 把所有的可能类型列举出来  typedef mkps<n<1>,n<2>,n<3>,n<4>,n<5>,n<6>,n<7>,n<8>,n<9> >::type EPS;  typedef filter<EPS,mkps<A,kind<9> >::type,FILTER>::type USED;  typedef mkps<n<1>,n<3>,n<4> >::type EXPECTED;  static_assert_same<EXPECTED,USED>();

从上面的代码可以看出：将函数封装到了类（A）域中，这样使用起来就方便多了。

上面的代码采用的基本方法是：依次测试每一个传入的参数，能够匹配传入参数的函数的 返回值类型不是kind<9>，而不匹配传入参数的函数，就会匹配省略号参数的函数，该函数 返回值类型就是kind<9>。把不匹配省略号参数函数的类型过滤出来，就是所需要的结果。

接下来的分析两个及两个参数以上的函数，也是采取的这种方法！从上面的代码中，还可 以看出，函数的名称被固定为on了！这是没有必要的，但是为了能够把函数名称和功能代 码分隔开，还需要提供一个FUNCTION模板： 

 struct A// 用类域把函数封装起来  {      kind<9> on(...);      char on(n<1>);      char on(n<3>);      char on(n<4>);  };  // 下面就是隔离出来的FUNCTION模板，可以通过宏的方式修改函数名称和类名  template<class Type,class Kind,class ArgPS>struct FUNCTION;  template<class Type,class Kind,class A0>struct FUNCTION<Type,Kind,p<A0> >  {      enum{i=sizeof(Type().on(A0()))!=sizeof(Kind)};      typedef n<i> type;  };  // 下面是分析代码的功能代码，已经和函数名称和类名分开了  template<class ENV,class H>struct FILTER;// filter需要的格式  template<class Type,class Kind,class H>struct FILTER<p<Type,p<Kind> >,H>  {      typedef typename FUNCTION<Type,Kind,p<H> >::type type;  };   // 把所有的可能类型列举出来  typedef mkps<n<1>,n<2>,n<3>,n<4>,n<5>,n<6>,n<7>,n<8>,n<9> >::type EPS;  typedef filter<EPS,mkps<A,kind<9> >::type,FILTER>::type USED;  typedef mkps<n<1>,n<3>,n<4> >::type EXPECTED;  static_assert_same<EXPECTED,USED>();

再利用和一个参数的重载分析一样的方法实现两个参数的重载函数的分析

函数模板声明(function.hpp)： 

 // 判定指定参数类型串中的类型  template<class Type,class Kind,class ArgPS>struct FUNCTION;

过滤器(filter.hpp)： 

 template<class Init,class H>struct FILTER;  template<class Type,class Kind,class Init,class H>  struct FILTER<p<Type,p<Kind,p<Init> > >,H>  {      // Init的长度就是函数参数的数量      typedef typename length<Init>::type Size;      // 清理出给定的参数中的有效参数      typedef typename partition<Init,any>::type TMP1;      // 尝试追加新的参数      typedef typename join<TMP1,p<H> >::type TMP2;      // 用any补全参数到Size数量      typedef typename resize<TMP2,Size,any>::type TMP3;      // 最后过滤出存在函数的参数列表      typedef typename FUNCTION<Type,Kind,TMP3>::type type;  };

映射(map.hpp)： 

 template<class Init,class H>struct MAP  {      // 将H附加到Init的末尾，形成新的参数列表      typedef typename join<Init,p<H> >::type type;  };

收缩(reduce.hpp)： 

 template<class Init,class H>struct REDUCE;  template<class Type,class Kind,class EPS,class Init,class H>  class REDUCE<p<Type,p<Kind,p<EPS,p<Init> > > >,H>  {      // 准备好的初始化filter参数      typedef p<Type,p<Kind,p<H> > > TMP0;      // 过滤出新的参数类型      typedef typename filter<EPS,TMP0,FILTER>::type TMP1;      // 清理出所有的给定的有效参数      typedef typename partition<H,any>::type TMP2;      // 将接着存在的参数附加到上一次的参数列表之后      typedef typename map<TMP1,TMP2,MAP>::type TMP3;      // 将这样的所有参数列表收集起来      typedef typename join<Init,TMP3>::type TMP4;  public:      // 为了reduce能够继续执行，需要将结果保存为reduce制定的格式      typedef p<Type,p<Kind,p<EPS,p<TMP4> > > > type;  };

参数初始化(initialize.hpp)： 

 template<class Size,class H>struct INITIALIZE  {      typedef typename resize<p<H>,Size,any>::type type;  };

串接处理多个参数(next.hpp)： 

 template<class Size,class H>struct NEXT  {      typedef typename resize<H,Size,any>::type type;  };

所有的函数模板声明（function1.hpp,function2.hpp,function3.hpp）： 

 template<class Type,class Kind,class A0>      struct FUNCTION<Type,Kind,p<A0> >// 一个参数的FUNCTION  {      enum{i=(sizeof(Type().operator()(A0()))!=sizeof(Kind))};      typedef n<i> type;// 必须将i隔离成为枚举类型，保持编译器之间的兼容性  };   template<class Type,class Kind,class A0,class A1>      struct FUNCTION<Type,Kind,p<A0,p<A1> > >// 两个参数的FUNCTION  {      enum{i=(sizeof(Type().operator()(A0(),A1()))!=sizeof(Kind))};      typedef n<i> type;// 必须将i隔离成为枚举类型，保持编译器之间的兼容性  };   template<class Type,class Kind,class A0,class A1,class A2>      struct FUNCTION<Type,Kind,p<A0,p<A1,p<A2> > > >// 三个参数的FUNCTION  {      enum{i=(sizeof(Type().operator()(A0(),A1(),A2()))!=sizeof(Kind))};      typedef n<i> type;// 必须将i隔离成为枚举类型，保持编译器之间的兼容性  };  //... 更多的函数

下面是上面的处理多个函数参数的测试用例： 

 struct A// 两个参数的被测试类型  {      undefined operator()(...);      char operator()(n<3>,n<5>);      char operator()(n<3>,n<2>);      char operator()(n<4>,n<7>);      char operator()(n<4>,n<6>);      char operator()(n<6>,n<3>);      char operator()(n<6>,n<4>);      char operator()(n<6>,n<4>,n<9>);// 即使存在其它参数数量也没有问题  };   typedef mkps<n<1>,n<2>,n<3>,n<4>,n<5>,n<6>,n<7>,n<8>,n<9> >::type EPS;  // 探测出两个参数的类型列表  typedef map<EPS,n<2>,INITIALIZE>::type INIT;// 将所有的参数初始化  typedef reduce<INIT,p<A,p<undefined,p<EPS,p<nil> > > >,REDUCE>::type USED;  //typedef reduce<INIT,mkps<A,undefined,EPS,nil>::type,REDUCE>::type USED;  typedef mkps<      mkps<n<3>,n<2> >::type,      mkps<n<3>,n<5> >::type,      mkps<n<4>,n<6> >::type,      mkps<n<4>,n<7> >::type,      mkps<n<6>,n<3> >::type,      mkps<n<6>,n<4> >::type  >::type EXPECTED;// 期待的类型串，注意，都是按照EPS里面列举的顺序排列的  static_assert_same<EXPECTED,at<USED,3>::type>();  
 struct B// 三个参数的被测试类型  {      undefined operator()(...);      char operator()(n<3>,n<5>,n<5>);      char operator()(n<3>,n<2>,n<4>);      char operator()(n<4>,n<7>,n<3>);      char operator()(n<4>,n<6>,n<2>);      char operator()(n<6>,n<3>,n<1>);      char operator()(n<6>,n<4>,n<7>);      char operator()(n<6>,n<4>);// 即使存在其它参数数量也没有问题  };   typedef mkps<n<1>,n<2>,n<3>,n<4>,n<5>,n<6>,n<7>,n<8>,n<9> >::type EPS;  // 探测出三个参数的类型列表  typedef map<EPS,n<3>,INITIALIZE>::type INIT0;// 将所有的参数初始化  typedef reduce<INIT0,p<B,p<undefined,p<EPS,p<nil> > > >,REDUCE>::type USED0;  typedef mkps<      mkps<n<3>,n<2> >::type,      mkps<n<3>,n<5> >::type,      mkps<n<4>,n<6> >::type,      mkps<n<4>,n<7> >::type,      mkps<n<6>,n<3> >::type,      mkps<n<6>,n<4> >::type  >::type EXPECTED0;// 期待的类型串，注意，都是按照EPS里面列举的顺序排列的  static_assert_same<EXPECTED0,at<USED0,3>::type>();  typedef map<at<USED0,3>::type,n<3>,NEXT>::type INIT1;// 将所有的参数初始化  typedef reduce<INIT1,p<B,p<undefined,p<EPS,p<nil> > > >,REDUCE>::type USED1;  typedef mkps<      mkps<n<3>,n<2>,n<4> >::type,      mkps<n<3>,n<5>,n<5> >::type,      mkps<n<4>,n<6>,n<2> >::type,      mkps<n<4>,n<7>,n<3> >::type,      mkps<n<6>,n<3>,n<1> >::type,      mkps<n<6>,n<4>,n<7> >::type  >::type EXPECTED1;// 期待的类型串，注意，都是按照EPS里面列举的顺序排列的  static_assert_same<EXPECTED1,at<USED1,3>::type>();

从上面的代码可以很容易看出，对于多于两个参数的函数的参数类型的测定可以采用这里 类似的方法很容易的得出，只是这里的代码只说明了原理，还不能以库的形式提供，每次 使用的时候还需要对这里给出的代码进行修改，接下来的几节中将会针对这里的这种情况 进行讨论，也就本书的核心：自动化的实现。

将2中的方法扩展到多个参数的自动化分析

所谓的自动化的方法就是把不能以库的形式提供的代码尽可能的以库的形式提供的方法， 同时还要保证有一致的应用界面，使得应用较为简洁。在这里将会详细的讨论将上面的原 理进行自动化封装。

在上面的代码中，已经将所有的重载函数封装到了一个类中，这样就将被测试对象具体化 了。同时还应当注意到：被测试函数的参数的数量应当是已知的，这个可以通过上一节的 测试函数参数的数量的功能得到。

为了将上面的测试代码能够以库的形势提供，还需要解决下面的几个问题：

  1. 提供所有的参数数量的FUNCTION。这一点不可满足，通常只能够给定一个比较大的值， 但是也足够了

  2. 前面代码里面的通用函数（参数为省略号的函数）的返回值（undefined）也应该和前 面判断函数参数数量的方案一样，也应当泛型化

  3. 将测量两个以上的参数的过程封装起来，给出一个比较简单的界面

接下来的任务是：使上面的封装更加通用化!

那么一个直接的问题就摆在了我们的面前： 通用化的封装的结果是什么 ？

为了尽可能的保证实用性，我们假定：

  1. 参数之间的前后顺序也需要保留下来

  2. 最后的结果就是一个类似于XML结构的 层级结构

有了这两条假定之后，目标就非常明确了，下面就来尝试对上面的简单封装的结果再次进 行封装：

下面就是处理一个参数到九个参数封装方案： 

 template<class ePS,class A,class K,template<class,class,class>class FUNCTION,class N=n<10> >  class function_parameter_kinds// 把EPS改为ePS，可以增强编译器之间的兼容性  {  #include "filter.hpp"  #include "map.hpp"  #include "reduce.hpp"  #include "initialize.hpp"  #include "next.hpp"      // 下面是静态循环语句，实现了从两个参数的函数开始到N个参数的测试功能      template<class Init,class i>struct Statement      {          typedef typename map<typename at<Init,3>::type,N,NEXT>::type INIT;          typedef typename reduce<INIT,p<A,p<K,p<ePS,p<nil> > > >,REDUCE>::type type;      };      template<class Init>struct Statement<Init,n<2> >      {          typedef typename map<ePS,N,INITIALIZE>::type INIT;          typedef typename reduce<INIT,p<A,p<K,p<ePS,p<nil> > > >,REDUCE>::type type;      };      // 注意这里的区间范围是[n<2>,END)，和STL的规范相兼容      typedef typename increase<N>::type END;      typedef typename loop<n<2>,END,increase,nil,Statement>::type USED;  public:      typedef typename at<USED,3>::type type;// 这才是需要的结果  };

Tip

  • 无以规矩，何以方圆。得到任何好处的同时当然也要付出一定的代价:)

在给出示例之前还需要强调一下！为了扩展性，将函数的名字采用分析函数参数数量的 AUTOCXX_DEFINE_FUNCTION宏进行了封装，使得可以自由定义函数名称。在这里是仿函数： 

 AUTOCXX_DEFINE_FUNCTION(operator(),FUNCTOR)

下面是采用function_parameter_kinds针对上面的类A的仿函数参数分析的示例代码： 

 typedef mkps<n<1>,n<2>,n<3>,n<4>,n<5>,n<6>,n<7>,n<8>,n<9> >::type EPS;  typedef function_parameter_kinds<EPS,A,undefined,FUNCTOR,n<2> >::type ARGS;  typedef mkps<      mkps<n<3>,n<2> >::type,      mkps<n<3>,n<5> >::type,      mkps<n<4>,n<6> >::type,      mkps<n<4>,n<7> >::type,      mkps<n<6>,n<3> >::type,      mkps<n<6>,n<4> >::type  >::type EXPECTED;// 期待的类型串，注意，都是按照EPS里面列举的顺序排列的  static_assert_same<EXPECTED,ARGS>();

下面是采用function_parameter_kinds针对上面的类B的仿函数参数分析的示例代码： 

 typedef mkps<n<1>,n<2>,n<3>,n<4>,n<5>,n<6>,n<7>,n<8>,n<9> >::type EPS;  typedef function_parameter_kinds<EPS,B,undefined,FUNCTOR,n<3> >::type ARGS;  typedef mkps<      mkps<n<3>,n<2>,n<4> >::type,      mkps<n<3>,n<5>,n<5> >::type,      mkps<n<4>,n<6>,n<2> >::type,      mkps<n<4>,n<7>,n<3> >::type,      mkps<n<6>,n<3>,n<1> >::type,      mkps<n<6>,n<4>,n<7> >::type  >::type EXPECTED;// 期待的类型串，注意，都是按照EPS里面列举的顺序排列的  static_assert_same<EXPECTED,ARGS>();

从上面的代码可以看出，我们已经成功的实现了前面一节的方案的封装，功能上面已经达 到了我们先前所讨论的所有功能了：）

pandaxcl
关注
专栏目录
C++程序设计原理-与-实践-第二版-基础篇.pdf
03-27
总之，《C++程序设计原理与实践》第二版基础篇是一本全面而深入的C++入门教程，它不仅涵盖了C++的基础语法和核心概念，还注重实践教学，使读者能够在学习过程中不断积累编程经验，成为一名熟练的C++开发者。
2019推荐-电大《C++语言程序设计》期末考试试题及答案小抄参考.doc
最新发布
11-19
这篇文档是针对电大《C++语言程序设计》课程的期末考试的一份参考资料，涵盖了C++的一些核心概念和语法。 1. **类和成员函数**： - 类是C++中的基本构造块，它定义了一组数据成员（变量）和成员函数（方法）。在类...
C语言程序设计基础-C++基础教程_完整版.doc
06-16
【C语言程序设计基础-C++基础教程_完整版】这篇文档是C++初学者的一份详细教程，由Juan Soulié编写，Jing Xu翻译。它涵盖了从C++的基础知识到高级特性，包括ANSI-C++标准的最新内容。教程以实用为主，每个小节都配...
交换函数2_swap_c++交换函数_
10-03
这里我们关注成员函数`swap`的实现，即`2_swap_c++交换函数`所涉及的内容。 在C++中，一个类的`swap`成员函数通常如下所示： ```cpp class MyClass { public: // 其他成员... void swap(MyClass& other) { // ...
boost-STL.rar_Boost_C++标准库_STL_c 标准库_chm
09-21
STL是C++编程中不可或缺的一部分，它包括了模板类和函数，如容器（如vector、list、set等）、迭代器、算法（如排序、查找）以及函数对象（如比较函数、操作符重载）。Boost.STL在STL的基础上，添加了许多实用的组件...
C++中使用STL轻松实现序列化
热门推荐
04-03 1万+
#if 0 在用C++编写应用程序的过程中，经常涉及到序列化的问题，但是序列化的问题通常都会有非常繁琐的过程代码需要书写，本文中就是通过简单的步骤实现了程序的序列化问题，简单直接，和其它的序列化方案有着很大的不同。 首先来看看简单的数据写入文件和从文件读入数据的代码： 特别注解：本人特别喜欢用STL来书写代码，一方面是便于移植，但是另一方却是在于用STL书写的代码简单直接，可读性
撤销和重做(Undo和Redo)的C++完美实现(7-A)
04-20 4719
#if 0 在上一章里面讨论了复合对象的问题。RoundRectangle类(b)方案是一个复合类方案，从上一章的内容我们可以看出虽然实现了一个RoundRectangle类确实是一个复合类，但是实现复合类是一个比较繁琐的事情，对于一个程序里面有很多这种类的情况，那么前一章里面的编码过程将会是一个非常繁琐的体力劳动。在这一章里面将使用模板元编程将这种繁琐的体力劳动自动化。 在给出实现之
撤销和重做(Undo和Redo)的C++完美实现(1)
04-02 4433
        经过一年多的时间的摸索，终于找到了一种比较完美的撤销和重做(Undo和Redo)的C++实现方案，因为现在很多的应用程序都需要这种功能，所以我将我的经历写出来让大家分享，同时也能够让更多的人帮助我来更加完善这种架构，同时也能够让更多的人能够利用这种架构更好的完成它的程序。这种架构充分利用了STL的容器和算法来简化代码，因此有着比较高的正确性和可读性。       在解析我的架构之前
撤销和重做(Undo和Redo)的C++完美实现(2)
04-03 3577
通过前面的讨论，我们所希望的是具备有“仿函数保存反操作法”的时间和空间优势，但是又不希望有“仿函数保存反操作法”的书写反操作的繁琐过程，另外还要保证代码的组织非常简洁，当然这是为了方便维护了：）#if 0 在前面的章节中讨论了目前常见的实现撤销和重做的方案，其中的仿函数保存反操作的方案的空间和时间优势非常吸引人，但是需要为每一个操作实现一个反操作，这个过程非常的繁琐，而且容易出错；更何况
自动化C++程序设计---分析C++类结构
10-23 3416
/*<![CDATA[*/body { color: #000; background-color: #fff; margin: 0px 10%; min-width: 720px; font-family: 新宋体; counter-reset: chapter section subsection subsubsection paragraph lchapt
自动化C++程序设计---C++里的模板语言
10-23 2973
/*<![CDATA[*/body { color: #000; background-color: #fff; margin: 0px 10%; min-width: 720px; font-family: 新宋体; counter-reset: chapter section subsection subsubsection paragraph lchapt
撤销和重做(Undo和Redo)的C++完美实现(4)
04-07 2943
#if 0 在上一篇文章中已经成功的将三个基本操作封装为三个基本命令，同时也将一个复合操作封装成了一个复合命令，另外也给出了简单的使用代码；从代码中可以看出，撤销和重做的过程还是比较晦涩，用户为了表达撤销和重做的过程还需要编写很多的额外代码，而且这种代码也没有很直接的表达撤销和重做的思想。为了更好的表达撤销和重做机制，并且更加简化客户端代码的书写，在本章中将会对前一章中给出的代码进行更深入的
应用篇_撤销(Undo)和重做(Redo)的C++自动化实现(2)---撤销和重做原理
10-11 2823
/*<![CDATA[*/body { color: #000; background-color: #fff; margin: 0px 10%; min-width: 720px; font-family: 新宋体; counter-reset: chapter section subsection subsubsection paragraph lchapt
撤销和重做(Undo和Redo)的C++完美实现(3)
04-04 2779
#if 0 在上一篇文章中，已经对三种基本操作的撤销和重做进行了细致的分析，并给出了示例代码，但是并没能够给出复合操作的示例代码。这里面有着比较深刻的原因，具体来说就是：复合操作里面保存的是三个基本操作以及子复合操作的任意组合，这里面本身就存在一个将三个基本操作和复合操作对象化的概念，在三个基本操作实现对象化之前是不能够讨论复合操作的！既然需要对三个基本操作进行对象化，同时还应该看到：复合操
撤销和重做(Undo和Redo)的C++完美实现(6)
04-15 2700
#if 0 在前面的章节中我们讨论的对象都是简单对象，那么什么是简单对象呢？关于这个问题，首先还是先关注一下C++语言里面的基本类型。C++语言里面的基本类型如下： char (signed,unsigned) int (signed,unsigned) short (signed,unsigned) long (signed,unsigned) flo
应用篇_撤销(Undo)和重做(Redo)的C++自动化实现(3)---撤销和重做的基本架构
10-11 2643
/*<![CDATA[*/body { color: #000; background-color: #fff; margin: 0px 10%; min-width: 720px; font-family: 新宋体; counter-reset: chapter section subsection subsubsection paragraph lchapt
应用篇_撤销(Undo)和重做(Redo)的C++自动化实现(6)---扩展的框架代码
10-11 2571
/*<![CDATA[*/body { color: #000; background-color: #fff; margin: 0px 10%; min-width: 720px; font-family: 新宋体; counter-reset: chapter section subsection subsubsection paragraph lchapt
自动化C++程序设计---分析C++类层次
10-23 2409
/*<![CDATA[*/body { color: #000; background-color: #fff; margin: 0px 10%; min-width: 720px; font-family: 新宋体; counter-reset: chapter section subsection subsubsection paragraph lchapt
应用篇_撤销(Undo)和重做(Redo)的C++自动化实现(1)---交换函数swap功能的讨论
10-11 2355
/*<![CDATA[*/body { color: #000; background-color: #fff; margin: 0px 10%; min-width: 720px; font-family: 新宋体; counter-reset: chapter section subsection subsubsection paragraph lchapt
C++程序设计：谭浩强版-面向对象编程基础
"C++程序设计 谭浩强 - 中国高等院校计算机基础教育课程体系规划教材" 本书"《C++程序设计》"是谭浩强教授编著的一本经典教材，旨在为中国高等院校的计算机基础教育提供系统性的学习资料。书中详细介绍了C++编程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值