【C++奇技淫巧】CRTP（奇特重现模板模式）

最新推荐文章于 2025-03-21 19:11:11 发布

LeoLei8060

最新推荐文章于 2025-03-21 19:11:11 发布

阅读量1.8k

点赞数 23

分类专栏： C++ 文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/LeoLei8060/article/details/139355345

版权

C++ 专栏收录该内容

28 篇文章

订阅专栏

CRTP（Curiously Recurring Template Pattern，奇特重现模版模式）,是一种在C++中使用模板来实现的设计模式，主要用于实现编译时多态性（静态多态）。这种模式通过类模板和模板继承机制来实现，使得派生类在继承时将自身作为基类模板的参数。

这里采用的中文名字参考了zh.cppreference.com

示例解析

template <typename T>
class Base {
public:
	void doSomething()
	{
		// 访问 Derived 类的成员
		static_cast<T*>(this)->implementation();
	}
};

class Derived : public Base<Derived> {
public:
	void implementation()
	{
		std::cout << "Derived::implementation()";
	}
};

int main()
{
	Derived d;
	d.doSomething();
	return 0;
}

输出结果：

Derived::implementation()

解析

编译器在编译上面代码时，因为延迟实例化，所以在Derived派生类后面实例化Base<Derived>。
在实例化的Base<Derived>类的doSomething()函数中，将this指针从Base<Derived>*转换成Derived*，这样就能访问Derived类中定义的方法了。

CRTP的多态性

C++多态的实现方式分为动态多态（虚函数）、静态多态（模板、函数重载）。
其中用模板实现静态多态的方式也有很多种：

函数模板
类模板
CRTP（通过模板继承实现）

动态多态和静态多态

动态多态

动态多态是通过虚函数来实现的。它允许在运行时确定调用哪个对象/方法，这主要依赖于虚函数表（vtable）来动态解析调用。

优点：

灵活性：可以在运行时改变对象的行为
易于使用：只需声明虚函数，让派生类重写函数即可

缺点：

性能开销：每次调用虚函数时都需要通过虚指针转到虚函数表，再找到对应的函数，花费时间长
内存开销：每个对象都需要额外的内存来存储指向虚函数表的指针。

静态多态

静态多态通常是通过模板实现的，它在编译时就明确了调用的对象/方法，而不是在运行时。

优点：

性能开销：没有运行时的多余开销，函数调用可以直接解析
内存开销：运行时不会有多余的内存开销

缺点：

代码膨胀：对于每个不同的类型，编译器可能都会生成一份代码，这可能导致最终编译出的二进制文件体积增大
灵活性较低：在编译时就已经确定了所有的类型，不能像动态多态那样在运行时改变对象的行为

CRTP和虚函数

性能与开销

CRTP：使用 CRTP 实现的是静态多态，即在编译时就解析函数调用，而不需要虚函数表，从而避免了运行时的查找开销。这种方法通过模板实例化直接绑定函数，因此运行效率更高，没有额外的内存开销。
虚函数：动态多态通过虚函数实现。虚函数依赖于虚函数表（vtable），这意味着每次调用虚函数时都需要通过虚函数表进行间接跳转。这种间接性带来运行时开销，同时每个使用虚函数的对象需要额外的内存来存储指向虚函数表的指针。

灵活性和可维护性

CRTP：CRTP 允许基类通过模板机制访问派生类的成员，这样可以将一些通用的功能封装在基类中，而具体的实现则在派生类中完成。CRTP 特别适合于实现混入（Mixins）类型的功能，能够在不修改原有类结构的情况下，为类增加额外的功能。
虚函数：虚函数提供了极高的灵活性，允许在运行时决定对象的行为。这使得代码可以容易地扩展和修改，但可能导致代码维护和理解的复杂度增加。

代码重用与扩展

CRTP：CRTP 允许基类通过模板机制访问派生类的成员，这样可以将一些通用的功能封装在基类中，而具体的实现则在派生类中完成。CRTP 特别适合于实现混入（Mixins）类型的功能，能够在不修改原有类结构的情况下，为类增加额外的功能。

上面提到的混入（Mixins）指的是在面向对象编程中用于增加类功能的技术，它通过多重继承将功能模块（Mixin类）混入到一个类中。这种方法允许程序员在不修改原始类代码的情况下为类添加新的行为和属性。

虚函数：通过虚函数，派生类可以覆盖基类中的行为，实现功能的自定义和扩展。这种方法简洁直观，易于理解和使用。

类型安全和错误检测

CRTP：由于 CRTP 是在编译时处理的，所以相关的类型错误会在编译阶段被捕捉和报告，增加了开发过程中的类型安全性。
虚函数：虚函数的错误（如类型不匹配）通常在运行时发现，有时这可能导致程序崩溃或不稳定。

CRTP的案例展示

`enable_shared_from_this`

enable_shared_from_this就是一个典型的CRTP案例，继承enable_shared_from_this类的对象可以从内部生成std::shared_ptr。

这个模板类最初是Boost库引入的，后面被纳入到C++标准库中，下面我们展示Boost库下的源码

namespace boost
{

template<class T> class enable_shared_from_this
{
protected:

    BOOST_CONSTEXPR enable_shared_from_this() BOOST_SP_NOEXCEPT
    {
    }

    BOOST_CONSTEXPR enable_shared_from_this(enable_shared_from_this const &) BOOST_SP_NOEXCEPT
    {
    }

    enable_shared_from_this & operator=(enable_shared_from_this const &) BOOST_SP_NOEXCEPT
    {
        return *this;
    }

    ~enable_shared_from_this() BOOST_SP_NOEXCEPT // ~weak_ptr<T> newer throws, so this call also must not throw
    {
    }

public:

    shared_ptr<T> shared_from_this()
    {
        shared_ptr<T> p( weak_this_ );
        BOOST_ASSERT( p.get() == this );
        return p;
    }

    shared_ptr<T const> shared_from_this() const
    {
        shared_ptr<T const> p( weak_this_ );
        BOOST_ASSERT( p.get() == this );
        return p;
    }

    weak_ptr<T> weak_from_this() BOOST_SP_NOEXCEPT
    {
        return weak_this_;
    }

    weak_ptr<T const> weak_from_this() const BOOST_SP_NOEXCEPT
    {
        return weak_this_;
    }

public: // actually private, but avoids compiler template friendship issues

    // Note: invoked automatically by shared_ptr; do not call
    template<class X, class Y> void _internal_accept_owner( shared_ptr<X> const * ppx, Y * py ) const BOOST_SP_NOEXCEPT
    {
        if( weak_this_.expired() )
        {
            weak_this_ = shared_ptr<T>( *ppx, py );
        }
    }

private:

    mutable weak_ptr<T> weak_this_;
};

} // namespace boost

下面展示使用标准库中的enable_shared_from_this示例：

#include <memory>
#include <iostream>

class MyClass : public std::enable_shared_from_this<MyClass> {
public:
    std::shared_ptr<MyClass> get_shared_ptr() {
        return shared_from_this();
    }
};

int main() {
    std::shared_ptr<MyClass> ptr = std::make_shared<MyClass>();
    std::shared_ptr<MyClass> another_ptr = ptr->get_shared_ptr();
    std::cout << "Same object: " << (ptr == another_ptr) << std::endl;
}

日志类

template<typename T>
class Logging {
public:
	void log(const std::string& message) const {
		// 获取派生类的名称，这里假设派生类有一个名为 getName 的方法
		std::cout << static_cast<const T*>(this)->getName() << ": " << message << std::endl;
	}
};

class Car : public Logging<Car> {
public:
	Car(const std::string& model) : model_(model) {}

	std::string getName() const { return model_; }

	void drive() {
		this->log("Starting the engine.");
		// 驾驶逻辑...
		this->log("Stopped the engine.");
	}

private:
	std::string model_;
};

class Robot : public Logging<Robot> {
public:
	Robot(const std::string& identifier) : identifier_(identifier) {}

	std::string getName() const { return identifier_; }

	void operate() {
		this->log("Activating robot.");
		// 操作逻辑...
		this->log("Deactivating robot.");
	}

private:
	std::string identifier_;
};


int main() {
	Car car("Toyota Camry");
	car.drive();

	Robot robot("Android 007");
	robot.operate();

	return 0;
}