前向报关混乱

Question

我正在创建一个需要调用compute的多线程类方法。

void compute(const Me::MyClass<T>& c1, Me:: MyClass<T>& target,std::size_t start);

namespace Me{
    template<typename T> class MyClass{

        computeMultiThreaded(){

            MyClass<T> target = MyClass();

            std::size_t n_threads = std::thread::hardware_concurrency();

            std::vector<std::tuple<std::size_t, std::size_t>> parts = split_job(n_threads, number_jobs);
            std::vector<std::thread> threads;

            for (std::size_t ti = 0; ti < n_threads; ti++)
            {
                // , parts[ti], minCol, this, m2, returnMatrix));
                threads.push_back(std::thread(compute,parts[ti]));
            }
        }
    }
}


void compute(const Me::MyClass<T>& c1, Me:: MyClass<T>& target,std::size_t start){
...
}

现在，当我尝试用在compute之后定义的MyClass编译它时，Me::MyClass在compute的第一个定义中并不为人所知。当我删除第一个声明时，在创建线程时不会知道compute？

我如何解决这个捕获22？

error: use of undeclared identifier 'Me'

Answer 1

问题是编译器在读取Me::MyClass的声明时不知道compute的存在。所以我们要做的就是告诉它这个类是存在的！

namespace Me {
    template<typename T> class MyClass;
}

以后可以像这样定义Me::MyClass

template<typename T> class Me::MyClass {
// insert your class definition
};

第一个片段是一个类声明，第二个是类定义。

Answer 2

在声明MyClass之前声明compute。如果您希望compute具有任意的MyClass<T>参数类型，那么它需要是一个函数模板。

namespace Me
{
    template<typename T>
    class MyClass;
}

template<typename T>
void compute(const Me::MyClass<T>& c1, Me:: MyClass<T>& target,std::size_t start);

Answer 3

您可以“向前声明”名称空间，并包含类的前向声明，然后在以后正确地完成您的工作：

namespace Me {
    template<typename T> class MyClass;
    template <class T>
    void compute(const MyClass<T>& c1, MyClass<T>& target, std::size_t start);
}

然后稍后：

//template<class T>
//void compute(const Me::MyClass<T>& c1, Me::MyClass<T>& target, std::size_t start); // Correct but it is already declared in namespace "Me"

现在的定义是：

namespace Me {
    template<typename T> class MyClass 
    {
        void computeMultiThreaded() { // I added void here so you should add a return type
            MyClass<T> target = MyClass();

            std::size_t n_threads = std::thread::hardware_concurrency();

            std::vector<std::tuple<std::size_t, std::size_t>> parts = split_job(n_threads, number_jobs);
            std::vector<std::thread> threads;

            for (std::size_t ti = 0; ti < n_threads; ti++)
            {
                // , parts[ti], minCol, this, m2, returnMatrix));
                threads.push_back(std::thread(compute, parts[ti]));
            }
        }
    }; // you missed also the semicolon in your example
}

template <class T>
void compute(const Me::MyClass<T>& c1, Me::MyClass<T>& target, std::size_t start) {

}

我希望这对你有用。