C++ c++；带有常量函数指针数组的模板化静态类

所以我真的需要一个具有以下结构的类，其中类是模板化的，

arr

是一个函数指针数组，但我似乎无法理解正确的语法：

--myclass.h--

#包括
模板
类MyClass{
类型定义无效（*fptr）（标准：：矢量数据）；
静态void foo（标准：：矢量数据）；
静态空心条（标准：：矢量数据）；
静态void baz（标准：：矢量数据）；
静态常数fptr arr[3]；
};

--myclass.cpp--

#包括“myclass.h”
#包括
模板void MyClass:：foo（std:：vector data）{…}
模板void MyClass:：bar（std:：vector data）{…}
模板void MyClass:：baz（std:：vector data）{…}
模板MyClass:：fptr MyClass:：arr[3]={&foo，&bar，&baz}；

---

如果有帮助的话，我的最终目标是让第四个成员函数从数组中调用

foo

、

bar

或

baz

，这样我就可以避免多个If-else语句的开销（我的实际实现有近50个这样的函数）。有更好的方法吗？

fptr

被声明为

const

，所以也定义它

const

。另外，由于

Sort

是一个模板，因此需要

typename

来引用

MyClass:：fptr

template<typename T>
const typename MyClass<T>::fptr MyClass<T>::arr[] = { &foo, &bar, &baz };

有更好的方法吗

---

可能吧，但是我不能不提供更多关于您想要做什么的详细信息。

将整个类模板移动到.hpp文件中，并使用声明的相同签名初始化

arr

：

template <typename T>
class MyClass {
    typedef void (*fptr)(std::vector<T> data);

    static void foo(std::vector<T> data) {}
    static void bar(std::vector<T> data) {}
    static void baz(std::vector<T> data) {}

    static const fptr arr[3];
};

template <typename T>
const typename MyClass<T>::fptr MyClass<T>::arr[] = { &foo, &bar, &baz };

输出：

foo 0
bar 0
bar 0
baz 0
baz 0
baz 0

---

您可以使用

std:：function

并将它们存储到向量中。以下是我到目前为止的想法

#include <exception>
#include <iostream>
#include <functional>
#include <vector>

template<typename T>
class MyClass {
private:
    std::vector<std::function<void(std::vector<T>)>> myFuncs_;

public:
    MyClass() = default;

    void addFunc( std::function<void(std::vector<T>)> func ) {
        myFuncs_.push_back(func);
    }

    void caller(unsigned idx, std::vector<T> v ) {
        return myFuncs_.at(idx)( v );
    }

    static void foo(std::vector<T> data) {
        std::cout << "foo() called:\n";

        for (auto& d : data)
            std::cout << d << " ";
        std::cout << '\n';
    }

    static void bar(std::vector<T> data) {
        std::cout << "bar() called:\n";

        for (auto& d : data)
            std::cout << d << " ";
        std::cout << '\n';
    }
};

int main() {
    try {
        MyClass<int> myClass;
        std::vector<int> a{ 1,3,5,7,9 };
        std::vector<int> b{ 2,4,6,8,10 };

        std::function<void(std::vector<int>)> funcA = MyClass<int>::foo;
        std::function<void(std::vector<int>)> funcB = MyClass<int>::bar;
        myClass.addFunc( funcA );
        myClass.addFunc( funcB );

        myClass.caller(0, a);
        myClass.caller(1, b);       

    } catch( std::runtime_error& e ) {
        std::cerr << e.what() << std::endl;
        return EXIT_FAILURE;
    }
    return EXIT_SUCCESS;    
}

---

不确定这是否正是你想要的。在本例中，

MyClass:：caller（…）

采用两个参数，即指向所需函数指针的向量的索引，以及函数作为输入所需的参数或数据

您有许多不相关的语法错误（额外的分号、额外的

static

关键字、不正确的typedef、冲突的名称等等）。在提出问题之前先解决这些问题。更好的是，提供一个可编译的示例，并询问如何向其中添加所需内容。您知道，是吗？您确定要复制所有函数中的向量吗？对于所有不相关的错误，我深表歉意。希望我在编辑中修正了这些，使事情更清楚。我只是不想复制粘贴700行代码。与原始阵列相比，使用

std:：array

有什么好处？@KodyPuebla与其他标准容器的一致接口。。。您得到迭代器，

std:：array

作为引用传递，保留其类型（而数组衰减为指针），因此e。G大小仍然可用，…@KodyPuebla它的方法，它不会衰减为指针的事实，以及味道。没有任何开销。

template <typename T>
class MyClass {
    typedef void (*fptr)(std::vector<T> data);

    static void foo(std::vector<T> data) {}
    static void bar(std::vector<T> data) {}
    static void baz(std::vector<T> data) {}

    static const fptr arr[3];
};

template <typename T>
const typename MyClass<T>::fptr MyClass<T>::arr[] = { &foo, &bar, &baz };

#include <iostream>
#include <vector>
#include <array>

template <typename T>
class MyClass {
    typedef void (*fptr)(std::vector<T> data);

    static void foo(std::vector<T> data) {
        for(int i : data) std::cout << "foo " << i << "\n";
    }
    static void bar(std::vector<T> data) {
        for(int i : data) std::cout << "bar " << i << "\n";
    }
    static void baz(std::vector<T> data) {
        for(int i : data) std::cout << "baz " << i << "\n";
    }
public:
    static constexpr std::array<fptr,3> arr = { &foo, &bar, &baz };
};

int main() {
    MyClass<int> a;
    a.arr[0](std::vector<int>(1));
    a.arr[1](std::vector<int>(2));
    a.arr[2](std::vector<int>(3));
}

foo 0
bar 0
bar 0
baz 0
baz 0
baz 0

#include <exception>
#include <iostream>
#include <functional>
#include <vector>

template<typename T>
class MyClass {
private:
    std::vector<std::function<void(std::vector<T>)>> myFuncs_;

public:
    MyClass() = default;

    void addFunc( std::function<void(std::vector<T>)> func ) {
        myFuncs_.push_back(func);
    }

    void caller(unsigned idx, std::vector<T> v ) {
        return myFuncs_.at(idx)( v );
    }

    static void foo(std::vector<T> data) {
        std::cout << "foo() called:\n";

        for (auto& d : data)
            std::cout << d << " ";
        std::cout << '\n';
    }

    static void bar(std::vector<T> data) {
        std::cout << "bar() called:\n";

        for (auto& d : data)
            std::cout << d << " ";
        std::cout << '\n';
    }
};

int main() {
    try {
        MyClass<int> myClass;
        std::vector<int> a{ 1,3,5,7,9 };
        std::vector<int> b{ 2,4,6,8,10 };

        std::function<void(std::vector<int>)> funcA = MyClass<int>::foo;
        std::function<void(std::vector<int>)> funcB = MyClass<int>::bar;
        myClass.addFunc( funcA );
        myClass.addFunc( funcB );

        myClass.caller(0, a);
        myClass.caller(1, b);       

    } catch( std::runtime_error& e ) {
        std::cerr << e.what() << std::endl;
        return EXIT_FAILURE;
    }
    return EXIT_SUCCESS;    
}

MyClass::foo() was called:
1 3 5 7 9
MyClass::bar() was called:
2 4 6 8 10