C++模板

题外话,为什么我学习C++？主要原因看到是GUIlite是用C++写的，如果不会C++，无法很好的使用；

为什么我要 了解C++的template模板，因为我在学习scmRTOS，这也是用C++写的，使用大量的

C++命名空间和C++模板，如果你不学习的话，也无法很好的使用scmRTOS; 

 

话说template模板最大的思想，就是简化重复操作，只要我们定义好模板，C++编译器就可以帮我们写代码。

一般分为：函数模板和类模板。用户基本上就是使用这俩种了。。

 

看了很多视频，网上的应例子，感觉C++真的很强大。

另外总结一下，实现函数重载方法：

1.  使用虚函数，

2.  定义不同的命名空间，

3.  使用模板功能，

 

函数重载其实就是人们常提及的多态功能；C++中最重要的是概念，思想，语意，然后才到我们实际写的代码。

比如，模块就是为了简化工作，让C++自动为我们写代码。。。。

 

时间：2021-10-30

测试函数模板，如下所示：

#include <iostream>
#define log(x) std::cout<<x<<std::endl
using namespace std;

/* C++模板 */
template<class T>
T subt(T x, T y)
{
    T res;
    res = x + y;
    return res;
}

/* 测试mian */
int main(void)
{
   log(subt(2, 3));
   log(subt(2.5, 3.3));    
   return 0;
}  

执行结果：

  从执行结果可以看到，编译器自动帮我们写好了代码。

  

测试类的模板，如下所示：

#include <iostream>
#define log(x) std::cout<<x<<std::endl
using namespace std;

/* C++模板2 */
template<class T>
class YourClassName {
        T res;    // 数据
        
public:
        T subt(T x, T y) // 操作功能
        {
            res = x + y;
            return res;
        }
};


/* 测试mian */
int main(void)
{
   YourClassName<float> ooj;  // 实例化一个对像；
   YourClassName<int> ooj1;   // 实例化一个对像；
   
   log(ooj.subt(3.1, 3.6));   // 使用对像的成员函数
   log(ooj1.subt(3.1, 3.6));
   
   return 0;
}  
  

执行如下：

  

最后放一段OS里面例子：

    //--------------------------------------------------------------------------

    //--------------------------------------------------------------------------
    //
    //   process
    //
    //   Implements template for application processes instantiation
    //
    //      DESCRIPTION:
    //
    //
    #if SEPARATE_RETURN_STACK == 0

        template<TPriority pr, size_t stack_size>
        class process : public TBaseProcess
        {
        public:
            INLINE_PROCESS_CTOR process();

            OS_PROCESS static void exec();

        #if scmRTOS_PROCESS_RESTART_ENABLE == 1
            INLINE void terminate();
        #endif


        private:
            stack_item_t Stack[stack_size/sizeof(stack_item_t)];
        };

        template<TPriority pr, size_t stack_size>
        OS::process<pr, stack_size>::process() : TBaseProcess( &Stack[stack_size/sizeof(stack_item_t)]
                                                             , pr
                                                             , reinterpret_cast<void (*)()>(exec)
                                                         #if scmRTOS_DEBUG_ENABLE == 1
                                                             , Stack
                                                         #endif
                                                             )
        {
        }

        #if scmRTOS_PROCESS_RESTART_ENABLE == 1
        template<TPriority pr, size_t stack_size>
        void OS::process<pr, stack_size>::terminate()
        {
            TCritSect cs;

            reset_controls();
            init_stack_frame( &Stack[stack_size/sizeof(stack_item_t)]
                              , reinterpret_cast<void (*)()>(exec)
                          #if scmRTOS_DEBUG_ENABLE == 1
                              , Stack
                          #endif
                            );
        }
        #endif // scmRTOS_RESTART_ENABLE

        typedef OS::process<OS::prIDLE, scmRTOS_IDLE_PROCESS_STACK_SIZE> TIdleProc;

    #else  // SEPARATE_RETURN_STACK

        template<TPriority pr, size_t stack_size, size_t rstack_size>
        class process : public TBaseProcess
        {
        public:
            INLINE_PROCESS_CTOR process();

            OS_PROCESS static void exec();

        #if scmRTOS_PROCESS_RESTART_ENABLE == 1
            INLINE void terminate();
        #endif

        private:
            stack_item_t Stack [stack_size/sizeof(stack_item_t)];
            stack_item_t RStack[rstack_size/sizeof(stack_item_t)];
        };

        template<TPriority pr, size_t stack_size, size_t rstack_size>
        process<pr, stack_size, rstack_size>::process() : TBaseProcess( &Stack[stack_size/sizeof(stack_item_t)]
                                                                      , &RStack[rstack_size/sizeof(stack_item_t)]
                                                                      , pr
                                                                      , reinterpret_cast<void (*)()>(exec)
                                                                 #if scmRTOS_DEBUG_ENABLE == 1
                                                                      , Stack
                                                                      , RStack
                                                                 #endif
                                                                      )
        {
        }

        #if scmRTOS_PROCESS_RESTART_ENABLE == 1
        template<TPriority pr, size_t stack_size, size_t rstack_size>
        void OS::process<pr, stack_size, rstack_size>::terminate()
        {
            TCritSect cs;

            reset_controls();
            init_stack_frame( &Stack[stack_size/sizeof(stack_item_t)]
                            , &RStack[rstack_size/sizeof(stack_item_t)]
                            , reinterpret_cast<void (*)()>(exec)
                        #if scmRTOS_DEBUG_ENABLE == 1
                            , Stack
                            , RStack
                        #endif
                            );
        }
        #endif // scmRTOS_RESTART_ENABLE

        typedef OS::process< OS::prIDLE
                           , scmRTOS_IDLE_PROCESS_DATA_STACK_SIZE
                           , scmRTOS_IDLE_PROCESS_RETURN_STACK_SIZE> TIdleProc;

    #endif    // SEPARATE_RETURN_STACK
    //--------------------------------------------------------------------------

使用的时候像这样：

//---------------------------------------------------------------------------
//
//      Process objects   申明一个对像
//
OS::process<OS::pr0, 400> Proc1;



//---------------------------------------------------------------------------
template<> OS_PROCESS void OS::process<OS::pr0, 400>::exec()
{
    for(;;)
    {
        //--------------------------------------------------
        //
        //            Message test
        //
        //
        //     Receive data as message
        //
        MamontMsg.wait();          // wait for message
        MamontMsg.out(Mamont);     // read message content to global test object
        if(Mamont.src == TMamont::PROC_SRC)
        {
            ; // Make some actions
        }
        else
        {
            ; // Make some actions
        }
    }
}

Proc1是一个对像，而这个template<> OS_PROCESS void OS::process<OS::pr0, 400>::exec()
是类的成员函数;


哎，有点乱了，template<> OS_PROCESS void Proc1::exec()不好一点吗？
不行的，回顾下知识点，所有的类有成员数据和成员函数，一般数据私有，函数可以供外设调用；

而Proc1是由类实例化的对像。