是否正确使用函数的显式模板实例化？
在云计算领域中，函数的显式模板实例化是一种编程技术，用于在编译时生成特定类型的函数实例。它可以提高代码的性能和可维护性，同时减少代码的重复性。
函数的显式模板实例化可以通过在代码中使用特定类型的模板参数来实现。这样，编译器在编译时会根据模板参数生成相应类型的函数实例，而不是在运行时动态生成。
优势：
- 性能优化：显式模板实例化可以在编译时生成特定类型的函数实例，避免了运行时的类型推导和动态生成，提高了代码的执行效率。
- 可维护性：通过显式模板实例化，可以明确指定函数的参数类型，使代码更加清晰和易于理解。
- 代码复用：通过模板的参数化，可以在不同的上下文中重用同一个函数模板，减少了代码的重复性。
应用场景：
- 大规模数据处理：在云计算中，处理大规模数据是常见的需求。使用函数的显式模板实例化可以针对不同类型的数据生成高效的处理函数，提高数据处理的效率。
- 并行计算：云计算中的并行计算需要高效的算法和数据结构支持。通过显式模板实例化，可以生成针对不同并行计算场景的优化函数，提高并行计算的性能。
推荐的腾讯云相关产品和产品介绍链接地址：
- 腾讯云函数计算（云函数）：https://cloud.tencent.com/product/scf 腾讯云函数计算是一种事件驱动的计算服务，支持多种编程语言和触发器，可以实现函数的显式模板实例化和自动扩缩容，适用于云计算中的函数开发和部署。
总结： 函数的显式模板实例化是一种在云计算领域中常用的编程技术，通过在编译时生成特定类型的函数实例，提高了代码的性能和可维护性。它适用于大规模数据处理和并行计算等场景，腾讯云函数计算是一个推荐的云计算产品，可以支持函数的显式模板实例化和自动扩缩容。
相关·内容
3回答
我正在开发一个代码库，它使用以下结构：
a.h：
template<int N> void f();
void b();
a.cpp：
#include "a.h"
template<> void f<1>() {}
int main()
{
b();
}
b.cpp：
#include "a.h"
void b()
{
f<1>();
}
代码显示生成和运行正确。
我的问题是:这是一种格式良好的NDR，还是某种不正确的NDR？
如果使用clang -Wundefined-func-templ
浏览 14提问于2020-04-11得票数 1
2回答
关于显式模板实例化的混淆
、、、、
嗯，我想我只是被显式模板实例化~>_<~弄糊涂了。
显式实例化声明可以利用隐式实例化定义吗？
如果程序中同时存在显式和隐式实例化定义，怎么办？它们最终会崩溃成一个单一的吗？
在隐式实例化定义之后放置显式实例化声明是否有任何效果？
另外，请参见以下代码：
#include <iostream>
#include <vector>
std::vector<int> a; // Implicit instantiation definition.
// Explicit instantiation declaration.
e
浏览 3提问于2015-10-01得票数 2
在中，可接受的答案涉及头文件中的模板函数声明，该文件在源文件中有其定义。为了使该模板函数在其他翻译单元中也可用，在源文件中为每个“允许”使用进行显式模板实例化。到目前为止，在我看来，这似乎是标准做法。
但是，答案还建议在头文件中放置相应的显式模板实例化声明。我以前从未见过这种做法，我想知道这是否符合标准。
下面是一个小例子：
A.h
struct A
{
template<class T>
void g(T t);
};
A.cpp
#include "A.h"
template<class T>
void A::g(T t)
{ /*
浏览 0提问于2018-06-28得票数 0
回答已采纳
可以显式实例化模板函数的一个或多个特殊化吗？其次，函数是否是类成员有关系吗？它是合法的C++11吗，编译器也接受它，所以它不会有问题吗？
浏览 0提问于2013-06-19得票数 0
回答已采纳
C++03的显式模板的实例化定义和C++11的显式模板的实例化声明之间有什么区别？
我的意思是为什么实例化定义不足以阻止编译器为其他类型生成实现？下面的示例有什么问题:假设我将模板声明和定义分成两个单独的文件：
A.h
#pragma once
template<typename T>
class A
{
public:
A(T t);
private:
T _t;
};
A.cpp
#include "A.h"
template<typename T>
A<T>::A(T t) : _t(t) {}
template
浏览 3提问于2014-07-31得票数 28
回答已采纳
1回答
我已经开始玩extern模板了，我偶然发现了一个问题，我找不到任何相关的信息。假设我有一个带有非模板朋友函数的类模板(在类模板声明中定义)。我为类声明了一些extern模板实例化，但是如何也将朋友函数声明为extern？
下面是一些示例代码：
// --- test.h ---
template <typename T>
class Foo {
private:
T value;
public:
friend void some_friend_function(Foo<T>& obj) {
obj.value -= T(42
浏览 1提问于2012-10-13得票数 4
回答已采纳
1回答
我过去经常做这里建议的事情，将模板头和实现分开。我们基本上在.cc文件末尾显式实例化所需的模板，以便编译单元包含足够的信息供链接器使用。
最近我了解到，我们只需要显式实例化类构造函数就可以创建实例。例如,
// .h file
template<typename T>
class A {
public:
A(T& t) : t_(t) {};
void PublicMethod();
private:
void PrivateMethod();
T& t_;
};
// .cc file
template<typename T>
浏览 2提问于2022-10-15得票数 0
回答已采纳
6回答
在C++模板的上下文中，专门化和实例化有什么区别。根据我到目前为止所读到的内容，以下是我对特殊化和实例化的理解。
template <typename T>
struct Struct
{
T x;
};
template<>
struct Struct <int> //specialization
{
//code
};
int main()
{
Struct <int> s; //specialized version comes into play
Struct <float> r; //
浏览 0提问于2010-10-12得票数 49
2回答
static_cast<the_template<int>*>(0) -这个用int类型实例化the_template吗？
问这个问题的原因是下面的代码，它会在链接到Clang和GCC 4.4.5的未定义的check_error<char>(void*, long)引用时出错，这表明它没有实例化模板。不过，MSVC和编译和链接都很好，这使得人们相信它确实实例化了模板。但是，如果忽略强制转换，MSVC和GCC ( 4.4.5和4.5.1)只会在check_error<char>上出错(被通缉的行为)，而Clang则会在这两个调用上出错。通常情况下，
浏览 3提问于2011-12-04得票数 29
回答已采纳
3回答
显式实例化
、、
这是由的文章(第5页)激发的
template<class T>
T const &f(T const &a, T const &b){
return (a > b ? a : b);
}
template int const &f<int>(int const &, int const &);
int main(){
int x = 0, y = 0;
short s = 0;
f(x, y); // OK
f(x, s); // Is this cal
浏览 1提问于2010-09-16得票数 1
考虑下面的代码片段：
template <typename>
struct X { };
extern template struct X<int>;
int main()
{
X<int>{};
}
它编译并链接：。由于extern template声明，我希望它不会链接。
我的理解是，extern template的意思是：“请不要在这个TU中实例化这个特定的模板专门化，它将由其他TU提供，您可以链接到它”。
示例/描述。我在isocpp和cppreference上看到的似乎验证了我的心理模型。例如。
来自的：
显式实例化声明(外部模板)跳过
浏览 101提问于2019-06-05得票数 6
回答已采纳
1回答
这是C++11中外部模板的正确用法吗？(是否可以在同一翻译单元中看到extern template class和相应的template class？)
// example.hpp:
#pragma once
template< typename T >
class C {
void f(T);
};
// question is about the next two lines
extern template class C< float >;
extern template class C< double >;
// example_def.hp
浏览 0提问于2012-12-24得票数 3
回答已采纳
2回答
强制实例化所有模板类成员函数
、、、、
在模板类的初始开发过程中，在编写完整的测试用例之前，我发现我希望能够强制编译器为模板类的每个成员(包括非静态成员)为一组特定的模板参数生成代码，以确保至少编译所有代码。
具体来说，我使用的是GCC 9(我真的不需要其他编译器的这种能力，因为它只是我想在开发过程中临时实现的东西)；以及它的c++14、c++17、c++2a和c++20标准。
例如，我可以编写以下代码：
template <typename D> struct test_me {
D value;
void mistake1 () { value[0] = 0; }
void mistake2 () { m
浏览 4提问于2020-12-29得票数 1
回答已采纳
考虑一些函数模板，例如：
template <class T>
const auto& foo() { static T t; return t; }
如果T为void，则定义无效。尽管如此，我们还是可以单独实例化声明，而不会触发错误：
extern template const auto& foo<void>(); // explicit instantiation declaration
现在，让我们考虑调用foo的情况，而不是显式实例化。显然，如果在计算上下文中调用foo，则将实例化专门化的定义。那么在未评估的上下文中呢？我们知道，如果在未计算的
浏览 6提问于2020-11-19得票数 5
回答已采纳
我一直在仔细研究C++中的模板，而且我发现，似乎没有一组固定的严格术语可以清楚地识别和区分/消除使用模板时可能出现的每个语法元素的歧义，这一点具有挑战性。
例如，Josuttis和Vandevoorde的关于模板的书，，是一本非常出色的书，但即使是这本书也没有明确指出每一个涉及模板的语法元素的严格术语。相反，意义是明确的，从上下文。
考虑下面的简单示例，我相信它突出了涉及模板的11个不同的相关语法组件。
#include <iostream>
#include <vector>
template
<
typename
浏览 0提问于2012-11-28得票数 0
回答已采纳
2回答
我正在编写一个类IteratorIterable，它封装了一个容器类(一个带有返回一些迭代器的begin()和end()方法的类)，以便能够在包装类的迭代器上进行迭代。这个想法是基于的。我的代码如下所示(为了简洁起见，有些方法漏掉了)：
template <class T>
class IteratorIterable
{
private:
T& container;
public:
typedef decltype(container.begin()) BackendIterator;
public:
class IteratorIterato
浏览 0提问于2014-08-20得票数 1
回答已采纳
2回答
C++模板完全专门化语法
、、、
当您声明模板专门化时，使用(1)和不带角括号(2)的语法有什么区别。
如果没有提供方法的实现(定义)和错误：undefined reference to int f<int>(int)，那么版本1为什么会失败？
template <typename T> T f(T val) {
return val;
}
template<> int f<int>(int val); // 1
template int f<int>(int val); // 2
int main() {
cout << f(555)
浏览 3提问于2015-09-11得票数 1
回答已采纳
1回答
当我们有一个具有非类型模板参数的模板类(或函数)时，编译器如何生成版本？当然，它不会为N的每一个可能值创建一个版本
假设像std::array<T,N>这样的东西？
我正在尝试用size_t模板参数编写我自己的模板函数，并试图弄清楚是否/如何显式实例化我将使用的版本。
(我把程序分成不同的翻译单位)
我有一个模板函数，类似于
template <size_t N>
std::bitset<N> f(std::bitset<N> A){}
我将声明放入头文件，将定义放入.cpp文件。它不能生成正确的版本。所以我试图显式地实例化它
template
浏览 2提问于2022-07-28得票数 -1
回答已采纳
1回答
C++中删除函数模板的显式实例化
、、、、
如果函数模板被标记为已删除，是否允许显式实例化它，如示例中所示：
template<class T>
int foo(T) = delete;
template int foo(int);
Clang和GCC允许这样做，而MSVC则打印错误：
error C2280: 'int foo<int>(int)': attempting to reference a deleted function
演示：
哪个编译器就在这里？
浏览 9提问于2021-12-09得票数 1
回答已采纳
3回答
考虑以下代码：
template <unsigned int N>
struct myclass
{
unsigned int f() {return N;}
unsigned int g() {static_assert(N > 0, ""); return N-1;}
};
问:我是否保证以下代码将编译：
myclass<0> c;
c.f();
但以下情况不会：
myclass<0> c;
c.f();
c.g();
浏览 5提问于2015-06-11得票数 12
回答已采纳
我正在尝试使用C++ 4.8.2 (Ubuntu14.04环境)编译g++脉冲国际象棋引擎。
在链接阶段，我得到以下错误：
Linking CXX executable pulse-
CMakeFiles/pulse.dir/main.cpp.o: In function `pulse::MoveGenerator::MoveGenerator()':
/home/user/cpp/movegenerator.h:15: undefined reference to `pulse::MoveList<pulse::MoveEntry>::MoveList()'
li
浏览 0提问于2014-11-17得票数 1
回答已采纳
2回答
约束成员函数与显式模板实例化
、、、、
G++和Clang++一致认为以下代码段是无效的C++：
template<int dim, int rank>
struct Tensor {};
template<int dim>
double InnerProduct(Tensor<dim, 1> const &, Tensor<dim, 1> const &)
{ return 0.0; }
template<int dim>
double DoubleInnerProduct(Tensor<dim, 2> const &, Ten
浏览 2提问于2020-06-30得票数 9
回答已采纳
1回答
我在c++中有一个关于部分类模板专门化的问题。我有一个带有两个模板T的A类，U，然后我想要两个具有独占方法print_me()的类专门化，只对这两个专门化可见。除此之外，我还需要完全专门化的成员函数-- add_integer/add_double。当我在头文件中实现这些方法时，它编译得很好。但是id确实希望我的实现在源文件中，这对于完全专门化的函数来说不是问题，但是对于部分函数来说不是问题。下面的代码有以下错误：
test.h:27:25: error: declaration of ‘void A<int, U>::print_me()’ outside of class is
浏览 4提问于2014-06-30得票数 1
回答已采纳
1回答
考虑下面的模板类
template<typename T>
struct Caller {
void func(const T &t) { t.func(); }
void gunc(const T &t) { t.gunc(); }
};
现在，让某些类Target只提供成员函数func()，而不提供gunc()，即
struct Target {
void func() const { /* ... /* }
};
模板实例化Caller<Target>有效吗？
GCC、clang以及VC++都接受这样的模板实例化。当然，调用
浏览 3提问于2016-07-22得票数 2
1回答
考虑以下代码
#include <iostream>
using namespace std;
struct Printer{
Printer(){
std::cout << "Created\n";
}
};
template<class Derived>
struct InitPrinter{
static Printer p;
};
template<class Derived>
Printer InitPrinter<Derived>::p;
struct My
浏览 3提问于2013-11-13得票数 3
回答已采纳
1回答
我在linux上有一个构建在静态库中的项目，然后我想将它包含在单元测试项目和应用程序项目中。
在这个图书馆里我有这样的东西：
template<class T> class A
{
public:
virtual T doStuff() = 0;
virtual void doOther(T a) = 0;
protected:
A() { ... }
};
class B : public A<int>
{
public:
B() { ... }
virtual int doStuff() { ... }
virtu
浏览 12提问于2015-04-11得票数 0
回答已采纳
1回答
以下是GCC 4.8.1 (与--std=c++11一起)的编译：
struct non_default_constructible { non_default_constructible() = delete; };
template<class T>
struct dummy {
T new_t() { return T(); }
};
int main(int argc, char** argv) {
dummy<non_default_constructible> d;
return 0;
}
棘手的部分是dummy<non_d
浏览 3提问于2014-09-30得票数 12
回答已采纳
我喜欢头文件作为自记录引用存在。我试图将它们保存在带有文档注释的声明中，然后在源文件中对所有实现进行编程。本质上是一个记录在案的界面。
我正在进行一个项目，大量使用模板，而不是用实现细节填充标头(我知道我仍然可以声明模板并在头后面定义它们，但这不能解决这个问题)，我选择这样做。
// foo.h
template<typename T>
class Foo {
public:
Foo();
T get_foo();
private:
T foo;
}
#include "foo.tpp"
// foo.tpp
template<typename
浏览 0提问于2022-01-04得票数 0
回答已采纳
1回答
gcc-4.9.2和clang-3.8在编译为C++98或C++11时都接受以下内容：
#include <cstdio>
template <typename T> void f(T) { printf("T\n"); }
template <> void f<int>(int) { printf("int\n"); } // explicit specialization
template <> void f<>(double) { printf("double\n
浏览 3提问于2015-09-25得票数 4
回答已采纳
1回答
注：几个相关问题(例如，)最终被标记为的副本。我知道这个特别的问题，并在相应的答案中遵循解决办法。但是，不同的编译器产生不同的行为，我不知道为什么。
我的库具有一个类模板，我希望为库中的某些模板参数提供实例，因为模板需要一些重要的编译时间。类模板可以如下所示(stack.hpp)
#ifndef MY_STACK
#define MY_STACK
template<class T>
class stack
{
public:
stack();
};
#endif
它的实现驻留在相应的stack.tpp文件中。
#ifndef MY_STACK_TPP
#define M
浏览 5提问于2020-02-14得票数 4
回答已采纳
2回答
gcc和克朗之间的不同行为一直存在着许多问题。然而，我还没有找到解决问题的办法。
我使用模板，并希望扩展类的定义和实现。我读到了(很多次)，我知道不同的可能性。我选择特定的声明，我想要支持哪些模板。通过以下方式：
template class Temp<char>;
template class Temp<double>;
如果我将这些行放在template.cc文件的末尾，我将选择支持哪些模板，这些模板实际上是有效的。然而，与gcc，我也可以写在头文件。Clang不支持它，我得到链接错误。
但是为什么呢？头文件中已使用模板的声明有什么问题？
这是我的玩具例
浏览 2提问于2015-12-15得票数 1
回答已采纳
我理解了模板的概念，以及为什么我们需要在头文件中定义模板成员函数。另一个选项是在cpp文件中定义模板函数并显式实例化模板类，如下所示。
template.h
#include <iostream>
using namespace std;
template <typename T> class myclass
{
public:
void doSomeThing();
};
template.cpp
#include <iostream>
#include "template.h"
using namespace
浏览 0提问于2019-11-06得票数 2
回答已采纳
1回答
我有一些玩具代码如下：
#include <iostream>
using namespace std;
template<typename T>
class MyClass{
T t;
};
template class MyClass<int>;
int main()
{
//template class MyClass<int>;
return 0;
}
以及：
#include <iostream>
using namespace std;
template<typename T>
cl
浏览 2提问于2017-05-07得票数 2
回答已采纳
2回答
在C中，部分编译是可能的，因为可以将整个*.c文件编译成机器代码，由链接器处理解析和重定位。这只是一个计算某些指令在最终可执行文件中的位移，或者知道某个全局变量的绝对地址的问题。
在C++中，似乎也可以这样做--在C++代码和等效C代码之间存在相当简单的映射(就编程语言之间的映射而言)。然而，模板似乎使事情复杂化了。
例如，如果我在1.c中使用一个1.c，那么由于模板类是由<vector>头指定的，所以编译器可以为int规范生成机器代码。假设在同一个项目中有一个文件2.c也依赖于std::vector<int>专门化，并且必须链接1.o和2.o。以后是否可以将1.c和2
浏览 2提问于2014-01-27得票数 2
回答已采纳
2回答
我需要能够将存根代码插入到模板函数中，其中存根代码是专门化的。如果我使用蹦床，大多数编译器都允许这样做，例如
template <class T>
T foo(T t) {
if(Stub<T>::enabled) {
return Stub<T>::stub(t);
}
/* actual code here */
}
/* use of foo occurs here */
template <>
int Stub<int>::stub(int) { /* stub code */ }
至少对于G
浏览 0提问于2019-08-22得票数 3
回答已采纳
关于显式实例化(当模板在头中声明并在cpp文件中定义时使用的IIRC，因为否则链接器将无法在其他地方使用它)，如果模板有一个静态成员变量，显式实例化是否也会实例化和创建静态成员变量？
浏览 4提问于2014-06-20得票数 8
回答已采纳
1回答
如果一个人有一个模板常数变量(例如，用于计算斐波纳契序列)，并且想为某个模板参数实例化它，那么在实例化过程中必须重复constexpr关键字吗？
template<int N> constexpr size_t fib = fib<N-1> + fib<N-2>;
template<> constexpr size_t fib<1> = 1;
template<> constexpr size_t fib<2> = 1;
//template constexpr size_t fib<70>; /
浏览 2提问于2021-09-03得票数 3
回答已采纳
请考虑以下几点：
#include <iostream>
template <typename T>
struct Foo
{
Foo (T v = {}) : var (v) {}
T var;
};
int main()
{
// Foo<int&> f; // cannot compile
int x = 42;
Foo<int&> f(x);
std::cout << f.var;
}
它在GCC 4.8中成功地建立和运行，但它是否严格合法？
T v =
浏览 2提问于2014-10-17得票数 7
回答已采纳
1回答
模板类成员函数
、、、、
我有一门课叫Time。只有两个私有成员：int hours和int minutes。公共访问说明符只包含加、减等功能。
但是有一个特殊的函数不像我想的那样。它在类中被声明为public。
这样，它就可以编译：
Time Time::operator*(const int &mult)
{
minutes = minutes*mult;
hours = hours*mult + minutes/60;
minutes %= 60;
return *this;
}
但是，如果这个论点不是na int，而是float或double呢？我认为使用模板是最好的选择，而不是
浏览 5提问于2013-07-04得票数 1
当我用g++ --std=c++98 -Wall -Werror -Wpedantic Test.cc编译下面的内容时，没有错误。
template <class T>
struct TemplateClass {
T *ptr;
TemplateClass(T *p): ptr(p) {}
int foo() {
return ptr->bar();
}
};
struct ExampleClass {
};
int main() {
TemplateClass<ExampleClass> x(new ExampleClass
浏览 1提问于2016-04-13得票数 6
回答已采纳
1回答
假设我有以下代码片段：
template <class T>
class Bar
{
// static_assert(sizeof(T) > 0); // (1)
public:
void method()
{
static_assert(sizeof(T) > 0); // (2)
}
};
class Foo; // (3)
template class Bar<Foo>; // (4)
class Foo{}; // (5)
如果取消对行(1)的注释，就会得到编译时错误“不完全类型T"，这
浏览 0提问于2019-01-01得票数 6
回答已采纳
2回答
有人能提供GCC和MS编译器在编译和/或链接时如何处理模板实例化的比较或具体细节吗？这个过程在静态库、共享库和可执行文件的上下文中不同吗？我在上找到了GCC是如何处理这件事的，但我不确定这些信息是否仍然是指目前的状况。在编译我的库时，我应该使用他们建议的标志吗?例如-fno-隐式-模板
我所知道的(可能不一定是正确的)是：
模板在实际使用时将被实例化。
模板将作为显式实例化的结果进行实例化。
重复实例化通常通过折叠重复实例化或将实例化推迟到链接时间来处理。
浏览 4提问于2011-08-24得票数 45
回答已采纳
是否有可能像-fno-implicit-templates那样禁止隐式实例化，但只针对一个模板？
我对不完整模板的隐式实例化有问题，这会导致编译失败(实现的一部分隐藏在源文件中，我不想让它出现在其他TUs中)。-fno-implicit-templates解决了这个问题，但却以使用STL和其他模板的问题为代价。
浏览 1提问于2014-03-31得票数 0
回答已采纳
假设我有这个程序
#include <iostream>
using namespace std;
template<typename T>
class A {
public:
void foo() { cout << "Inside foo" << endl; }
void bar() { cout << "Inside bar" << endl; }
};
int main() {
A<int> a;
a.foo();
return 0;
}
浏览 2提问于2014-01-16得票数 6
回答已采纳
1回答
考虑一下守则：
#include <iostream>
template <typename T>
void f(T)
{
std::cout << "Version 1" << std::endl;
}
template <typename T>
void f(T *)
{
std::cout << "Version 2" << std::endl;
}
template <>
void f<>(int *)
{
std::
浏览 2提问于2020-02-27得票数 2
回答已采纳
1回答
我得到了gcc 4.8.3和clang3.2一致的行为，但我不明白为什么会发生这种情况。尽管我对类模板有一个显式实例化，但是当我使用模板的一个完全专门化的实例时，代码并没有被生成，并且我得到了一个未定义的符号。
我在文件“temp.hpp”中有一个简单的类模板定义
#pragma once
template <typename T1>
class C
{
public:
C (T1 c) : d_c(c) {};
~C () = default;
void print ();
private:
T1 d_c;
};
注意，方法'print()‘是声明的
浏览 1提问于2015-07-31得票数 5
回答已采纳
2回答
c++中的外部模板构造函数
、、、、
在相当长的一段时间里，我一直在为将模板化函数的实现与定义分离的老问题而苦苦挣扎。C++0x的extern似乎可以解决这个问题，但是我没有正确地应用它
我的代码：
main.cpp
#include <iostream>
#include <string>
#include "lexer.h"
int main(int argc, char const *argv[]) {
std::string foo("foo");
new lexer((foo.begin()),(foo.end()));
return 0
浏览 0提问于2013-02-22得票数 0
回答已采纳
1回答
显式专业化认证是模板吗？
、、、
根据的说法，专门化是一个类/函数/...实例化的或显式专门化的。指出，一些显式专门化是模板，这使我相信显式专门化是专门化(在“从模板生成的实体”意义上)，而不是模板(有时)。
我的问题是，显式的特殊化是实际的具体实体(类/函数/...)，还是模板。如果不是，它们到底是什么?它们不是模板或专门化(遵循temp.spec p4提供的定义)
浏览 5提问于2019-05-29得票数 1
1回答
我正在使用一个代码库，它在a.cpp中有以下声明
template <int num_dim = 2>
int register_parameters();
extern template int register_parameters<2>(); // why is extern required here?
在b.cpp中，我们定义
template <int num_dim = 2> int register_parameters() {
// define stuff
}
template int register_parameters<
浏览 6提问于2022-05-09得票数 0
2回答
我们已经使用Boost构建了一个实例库，当我们尝试将该库集成到二进制文件中时，由于用于构建二进制文件的“-- C++ =explicit”选项，我们在链接时遇到了问题。
问题是，当我们使用( Sun CC编译器的) --instances=explicit选项时，它希望我们显式地实例化模板。当Boost在内部使用模板时，链接器会抛出“未定义的符号”错误--这是意料之中的，因为我们没有显式实例化Boost中使用的模板。
虽然我理解链接器在这里抛出错误的原因，但在代码中显式实例化所有boost模板看起来很棘手。因此，希望检查是否有任何解决方案/解决方法来使用Boost与Sun CC编译器的“-in
浏览 0提问于2011-10-10得票数 2
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
