模板类的对象的嵌套调用和构造函数调用顺序分析

在最近的c++项目中，框架里频繁使用模板类，并在类中有类对象指针的逐级传递和相互调用，逻辑关系复杂，因此写一个简单的例子便于理解框架。

将以下4个文件一起编译执行。

文件classA.h

类A含有成员函数get

#include <stdlib.h>
#include <stdio.h>
#include <iostream>
class A
{
        public:

                A()
                {
                 count=0;
                 std::cout << "A construct" << "\n";
                }
                void inc()
                {
                        count++;
                }
                int get()
                {
                        std::cout<<"A func:get()\n";
                        return count;
                }


        private:
                int count;



};

 

文件classB.h

定义了一个模板类B,成员函数Get中执行了一个get函数，所以套用这个模板的class T必须含有get这个成员函数，否则将出错。

#include <iostream>
template <class T>
class B
{
        public:
                B(){std::cout<<"B construct" << "\n";}
                int Get(T* handle){
                                        std::cout << "B func: Get()\n";
                                        handle->get();
                                        return 0;
                                  }

};

文件classC.h

类C中包含一个模板类对象成员_c，通过成员函数test，将类对象A的指针传递给模板类B,再通过模板B的成员函数Get，最终调用类A的成员函数get()。实现了类对象指针的逐级传递。

#include "classA.h"
#include "classB.h"
#include "iostream"
class C
{
        public:
                C(){std::cout<<"C construct\n";}
                void test(A* a) {
                    std::cout<<"C function:test()\n";
                    _c.Get(a); //调用模板类成员的函数
                 }

        private:
                B<A> _c;  //模板类成员
};

main.c文件

#include "classC.h"

using namespace std;

int main()
{
        C *c = new C();
        A *a = new A();
        c->test(a);

}

执行结果：

B construct
C construct
A construct
C function:test()
B func: Get()
A func:get()
 

总结：在创建类对象C时，因为C中包含模板类B的成员变量，所以会先调用B的构造函数，再调用C的构造函数。