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

在声明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);必须是函数模板。

{{1}}

Answer 2

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

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

您可以稍后定义Me::MyClass，如此

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

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

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) {

}

我希望这适合你。

前瞻声明一塌

3 个答案: