转发声明混乱

我正在创建一个多线程类方法，需要调用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'

来源

2017-08-28 El Dude

是否使用Me :: MyClass; 有帮助吗？ – tpdi

这是一个大型项目的简化示例... –

是的，因为在声明它之前使用了'Me'。所以命名空间必须在之前声明。 – Raindrop7

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

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

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

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

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

来源

2017-08-28 23:29:19

在声明compute之前声明MyClass。如果你想让它有任意的MyClass<T>参数类型，compute需要是一个函数模板。

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

来源

2017-08-28 23:29:26 Praetorian

可以“向前声明”的命名空间，并包括类的向前声明后来做的正确：

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

}

我希望这对你有用。

来源

2017-08-28 23:52:32 Raindrop7

转发声明混乱

回答

相关问题