ardupilot c++模板函数和模板类

目录

摘要

---

C++ 模板 模板是泛型编程的基础，泛型编程即以一种独立于任何特定类型的方式编写代码。 模板是创建泛型类或函数的蓝图或公式。库容器，比如迭代器和算法，都是泛型编程的例子，它们都使用了模板的概念。 每个容器都有一个单一的定义，比如 向量，我们可以定义许多不同类型的向量，比如 vector <int> 或 vector <string>。 您可以使用模板来定义函数和类。

---

1. 泛型编程

模板是泛型编程的基础，泛型编程即以一种独立于任何特定类型的方式编写代码。

模板是创建泛型类或函数的蓝图或公式。库容器，比如迭代器和算法，都是泛型编程的例子，它们都使用了模板的概念。

2.函数模板

模板函数定义的一般形式如下所示：

template  
ret-type func-name(parameter list)
{
   // 函数的主体
}

在这里，type 是函数所使用的数据类型的占位符名称。这个名称可以在函数定义中使用。

下面是函数模板的实例，返回两个数种的最大值：

3.类模板

正如我们定义函数模板一样，我们也可以定义类模板。泛型类声明的一般形式如下所示：

下面的实例定义了类 Stack<>，并实现了泛型方法来对元素进行入栈出栈操作：

#include 
#include 
#include 
#include 
#include 

using namespace std;

template 
class Stack {
  private:
    vector elems;     // 元素

  public:
    void push(T const&);  // 入栈
    void pop();               // 出栈
    T top() const;            // 返回栈顶元素
    bool empty() const{       // 如果为空则返回真。
        return elems.empty();
    }
};

template 
void Stack::push (T const& elem)
{
    // 追加传入元素的副本
    elems.push_back(elem);
}

template 
void Stack::pop ()
{
    if (elems.empty()) {
        throw out_of_range("Stack<>::pop(): empty stack");
    }
    // 删除最后一个元素
    elems.pop_back();
}

template 
T Stack::top () const
{
    if (elems.empty()) {
        throw out_of_range("Stack<>::top(): empty stack");
    }
    // 返回最后一个元素的副本
    return elems.back();
}

int main()
{
    try
    {
        Stack         intStack;  // int 类型的栈
        Stack stringStack;    // string 类型的栈

        // 操作 int 类型的栈
        intStack.push(7);
        cout << intStack.top() <

4.ardupilot 中的模板类

我们重点来看下下面的实现：

    FUNCTOR_TYPEDEF(scheduler_fastloop_fn_t, void);

其中FUNCTOR_TYPEDEF定义，scheduler_fastloop_fn_t是函数名字，void是函数类型

#define FUNCTOR_TYPEDEF(name, rettype, ...) \
    typedef Functor name

从上面可以看出是实现了定义一个函数类对象，这个对象带一个返回值为void的类型参数，并且这个scheduler_fastloop_fn_t对象具有Functor模板的功能。

template  //其中RetType是宏参数，Args是参数
class Functor
{
public:
    //constexpr常量,定义Functor带参数的构造函数
    constexpr Functor(void *obj, RetType (*method)(void *obj, Args...)) 
        : _obj(obj)
        , _method(method)
    {
    }

    // Allow to construct an empty Functor
    constexpr Functor(decltype(nullptr))
        : Functor(nullptr, nullptr) { }

    constexpr Functor()
        : Functor(nullptr, nullptr) { }

    // Call the method on the obj this Functor is bound to
    RetType operator()(Args... args) const
    {
        return _method(_obj, args...);
    }

    // Compare if the two Functors are calling the same method in the same
    // object
    inline bool operator==(const Functor& rhs)
    {
        return _obj == rhs._obj && _method == rhs._method;
    }

    // Allow to check if there's a method set in the Functor
    explicit operator bool() const
    {
        return _method != nullptr;
    }

    template
    static constexpr Functor bind(T *obj)
    {
        return { obj, method_wrapper };
    }

private:
    void *_obj;
    RetType (*_method)(void *obj, Args...);

    template
    static RetType method_wrapper(void *obj, Args... args)
    {
        T *t = static_cast(obj);
        return (t->*method)(args...);
    }
};