为什么在源文件中专门化模板不会导致错误？
在源文件中专门化模板不会导致错误的原因是因为专门化模板的设计目的就是为了提供一种可重用的代码结构，以便在不同的上下文中使用。通过将通用的代码逻辑和数据抽象出来，专门化模板可以根据特定的需求进行定制，而不会影响源文件中的其他部分。
专门化模板的使用可以提高代码的可维护性和可扩展性。当需要对源文件进行修改或添加新功能时，只需要修改或添加专门化模板，而不需要修改源文件本身。这样可以减少错误的引入，并且可以更好地组织和管理代码。
另外，专门化模板还可以提高代码的复用性。通过将通用的代码逻辑和数据抽象出来，可以在不同的项目中重复使用，从而减少重复编写相似代码的工作量。这样可以提高开发效率，并且可以保持代码的一致性和统一性。
在云计算领域中，专门化模板的应用非常广泛。例如，在云原生应用开发中，可以使用专门化模板来定义和管理容器化的应用程序。在服务器运维中，可以使用专门化模板来自动化部署和配置服务器。在网络安全中，可以使用专门化模板来定义和管理安全策略和访问控制规则。
腾讯云提供了一系列与专门化模板相关的产品和服务，例如腾讯云容器服务（Tencent Kubernetes Engine，TKE）、腾讯云云服务器（Tencent Cloud Virtual Machine，CVM）、腾讯云安全组（Tencent Cloud Security Group）等。这些产品和服务可以帮助用户更好地利用专门化模板来构建和管理云计算资源。具体产品介绍和链接地址可以参考腾讯云官方网站。
相关·内容
2回答
类模板专门化中的静态成员函数
、、、、
我正在努力访问定义在类模板中的静态成员函数。在头文件TemplateTest.h中，我将主类模板定义为：
#include<iostream>
template<class T, class U>
struct TemplateTest
{
public:
void static invoke();
/*{
std::cout << "Should not be called" << std::endl;
}*/
};
然后源文件TemplateTester.cpp我放了一个专门化：
浏览 0提问于2013-06-04得票数 7
回答已采纳
我正在使用下面的简单示例
struct foo
{
template <typename t>
void funct(t a , t b)
{
std::cout << "Primary template called";
}
};
template<>
void foo::funct<std::string> (std::string a , std::string b)
{
std::cout << "Specialized";
}
上面的代码
浏览 2提问于2015-10-06得票数 1
回答已采纳
我正在尝试使用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回答
我在类中使用静态模板成员；模板在软件中构建的cpp中实例化。我有一个插件软件，它在头中使用name()模板方法，但不构建包含实例化的源文件。构建在Linux上使用g++-4.9，但在MinGW 4.8上失败。我想知道如何使它与几乎相同的编译器一起工作，而是在Windows上工作。
.hpp：
enum class ToplevelMenuElement
{
FileMenu,
...
AboutMenu
};
enum class FileMenuElement
{
New,
... ,
Quit
};
// Others menus ma
浏览 1提问于2014-11-17得票数 0
考虑一下守则：
class Test {
public:
template<int N> auto foo() {}
template<> auto foo<0>() { return 7; }
template<int N> void bar() {}
template<> int bar<0>() { return 7; }
};
我已经用不同的编译器(通过)测试了代码。
对于Clang 7.0.0， foo编译，而bar提供了一个错误：
:8:20:错误:没有函数模板匹配函数模
浏览 0提问于2018-09-23得票数 4
回答已采纳
1回答
我有一个带有成员模板函数的类：
// writer.h
class Writer {
public:
...
template <typename T, typename V>
void addField(const std::string& name, V v)
{
// write something
}
};
在编写器的源文件中，我为some_type添加了显式的专门化
// writer.cpp
template <>
void Writer::addField<some_type, int
浏览 0提问于2015-05-29得票数 10
回答已采纳
2回答
我对SFINAE有一个基本的了解，我想我理解std::enable_if如何利用它来选择函数模板专门化的许多例子，但是我很难理解它如何为类模板工作。
下面的示例来自
template<class T, class Enable = void>
class A {}; // primary template
template<class T>
class A<T, typename std::enable_if<std::is_floating_point<T>::value>::type> {
}; // specializatio
浏览 6提问于2020-05-28得票数 3
回答已采纳
我理解了模板的概念，以及为什么我们需要在头文件中定义模板成员函数。另一个选项是在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
回答已采纳
4回答
我希望一个模板化类中的成员函数有几个不同的函数定义。如下所示：
template <typename T>
class MyClass
{
void Foo();
T val;
//other functionality and data
};
//handles all types
template <typename T>
void MyClass<T>::Foo()
{
return val;
}
//handles a special type in a different way
template <>
v
浏览 2提问于2011-11-20得票数 1
回答已采纳
2回答
我有一个类模板，简化了，有点像这样：
template<typename T>
class A
{
protected:
T _data;
public:
A* operator%(const A &a2) const
{
A * ptr;
ptr = new A(this->_data % a2._data);
return ptr;
}
};
另一个继承自这个类的类：
class B : public A<double>
{
// ...
};
但是当我这样做的时
浏览 2提问于2013-02-14得票数 2
回答已采纳
1回答
我在标头中声明了一个模板类，其中有一个方法，而在报头中没有该方法的定义。在.cc文件中，我定义了该方法的专门化，而没有在头中声明它们。在不同的.cc文件中，我对存在专门化的不同模板参数调用该方法。看起来是这样的：
F.h：
template<typename T>
class Foo {
public:
static int bar();
};
foo.cc：
#include "foo.h"
template<>
int Foo<int>::bar() {
return 1;
}
template<>
int Foo
浏览 2提问于2013-02-25得票数 13
回答已采纳
1回答
我正在实现边界Volumn层次结构，其中树具有如下模板：
template <typename Coordinate>
class BoundingTree { /* ... */ }
Coordinate可以是Vector2d、Vector3f或任何其他任意坐标。要使用这个BoundingTree结构进行碰撞检测，应该有一个检测函数：
template <typename Coordinate>
template <typename RigidBody>
bool BoundingTree::collide(RigidBody const &
浏览 3提问于2016-04-18得票数 0
回答已采纳
1回答
gcc找不到模板专门化
、、、
我的网络代码使用模板专门化来序列化不能简单复制的类型。我定义了一个通用模板
template<typename T> struct TypeHandler
它处理可以通过简单memcpy传输的所有类型，然后为所有其他类型定义专门化。现在的问题是，我有一个具有多个这样的专门化的文件，如果我用Visual编译代码，一切都很好。但是对于gcc，该文件中的所有模板专门化都会被使用，只有
template<> struct TypeHandler<uint32_t>
哪个变量长度编码整数以节省空间。
所有TypeHandler版本的名称空间都是相同的，甚至在同一个文件
浏览 3提问于2014-07-10得票数 2
2回答
解决这个问题的方法可能很琐碎，但我找不到。我试着搜索它，但没有运气。
我正在使用Linux10.1.0Ubuntu10.1.0-2ubuntu1-18.04版本(gcc版本10.1.0Ubuntu10.1.0Ubuntu1-18.04)进行C++项目。
g++将一个C++文件编译成一个对象.o，而不会引发任何错误，但是结束对象文件缺少一个函数！我编写的其他8个库文件都很好地编译和链接，只有这个给我带来麻烦。为什么，我该怎么解决？
库头文件bpo_interface.h是：
#pragma once
#include <boost/program_options/options_desc
浏览 3提问于2020-10-26得票数 0
1回答
以下代码(取自)定义了 pi<>
template<typename T=double>
constexpr T pi = T(3.14159265358979323846264338328);
template<>
constexpr const char* pi<const char*> = "π";
对于clang编译器(AppleClangVersion12.0.0)(使用C++14)，这将触发一个警告(使用-Weverything)：
以前没有关于非静态变量'pi<const char *>‘的外部
浏览 1提问于2021-02-18得票数 7
回答已采纳
1回答
这个问题出现在我们开发发动机的时候。我们想要
template <typename T>
std::pair<const uint8_t*, size_t> get_resource()
{
return {nullptr, 0ull};
}
重要的是我们希望在独立的源文件(.cpp)中进行专门化，并将其编译到引擎的静态库二进制文件中。在源文件中进行专门化是非常重要的，因为这些函数可能会频繁地被引擎的大型代码库(至少几十万LoC)的其他标头更改和使用。因此，如果他们生活在头文件中，如果更改了一个专门化的定义，就可能导致项目大部分的重构。对于这样的问题，我找不到帮
浏览 2提问于2020-03-20得票数 1
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
回答已采纳
1回答
我在读C++ Primer，上面写着：
“如果不使用成员函数，则不实例化成员。只有在使用成员函数时才实例化成员这一事实使我们可以实例化一个类，其类型可能不符合某些模板操作的要求。”
我不知道为什么这是个问题。如果需要一些操作，为什么编译器不实例化这些操作？有人能举个例子吗？
浏览 0提问于2015-01-06得票数 0
回答已采纳
1回答
例如，在此代码中：
#include <iostream>
#include <type_traits>
template<typename T>
requires std::is_same_v<T,int> || std::is_same_v<T,float> || std::is_same_v<T,double>
bool foo(const T& value)
{
return true;
}
template<>
bool foo<double>(const double
浏览 5提问于2020-10-09得票数 2
回答已采纳
当我用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
回答已采纳
3回答
自动销毁静态对象
、、
为什么C++不创建/销毁模板类型的静态成员。
观察以下示例：
#include <iostream>
struct Dump {
Dump() {
std::cout << "CTOR" << std::endl;
}
~Dump() {
std::cout << "DTOR" << std::endl;
}
};
template <typename T> struct X {
static Dump dump;
};
template <t
浏览 2提问于2011-09-22得票数 7
回答已采纳
2回答
class Myclass
{
template <typename T>
static T func()
{
T obj;
return obj;
}
template<>
static int func<int>()
{
}
};
我写了上面的课，并试图编译它。我发现了以下错误：
错误:在非命名空间范围“类Myclass”中显式专门化
错误:主模板声明中的模板id 'func‘
然后，我把我的静态函数移到了教室的外面，如下所示：
name
浏览 3提问于2017-07-14得票数 3
回答已采纳
2回答
我在用专门的破坏者做实验。这段代码是完全有效的，并且编译得很好：
#include <iostream>
using namespace std;
template <typename T>
class Cat
{
public:
~Cat();
};
template <typename T>
Cat<T>::~Cat()
{
std::cout << "T" << std::endl;
}
template <>
Cat<int>::~Cat()
{
浏览 0提问于2017-10-17得票数 1
回答已采纳
3回答
这个问题是在采访时提出的:这段代码会导致编译/链接错误吗?为什么会这样？
template <int T> void f();
template <> void f<0>() {}
void test()
{
f<1>();
}
请解释一下行为。非常感谢。
浏览 5提问于2014-05-21得票数 21
回答已采纳
2回答
在我正在复习的一些代码中，我遇到了Clang和Gcc不同意的情况。环顾四周，我似乎弄不清谁是对的。
免责声明：我知道有一个更好的单例模式，但这是代码中使用的模式。
备注：
gcc 7.4.0关于Ubuntu (无错误)
对Ubuntu的clang 6.0.0 (抛出错误)
所有post C++11 ISO版本似乎都存在差异，但我之前没有尝试过。
foo.hh
#include "sing.hh"
class Foo {
public:
Foo();
~Foo();
static Foo *getSingleton(){
浏览 0提问于2019-05-28得票数 3
回答已采纳
1回答
编辑了我的问题，请帮助:(
需要一点帮助。我使用STL向量，我有以下文件: vectorAux.h、vectorDriver.cpp和vectorAux.cpp
我想链接它并编译它。我最初问过关于显式实例化的问题，但是我意识到这个路径不是我想要的方式。我只是希望它能帮我解决编译它的问题。
我这样做是为了做家庭作业，它在这个头文件的底部写着"#include vectorAux.cpp“：
#include <iostream>
using namespace std;
#ifndef VECTORAUX_H
#define VECTORAUX_H
template&l
浏览 0提问于2015-10-13得票数 0
回答已采纳
有一些函子具有返回类型演绎，包括lambda表达式。
constexpr auto a = [](auto&& x){ return x + 1; };
struct X{
template<typename T>
auto operator()(T&& x){
return x + 1;
}
};
然后，我有两个函数来检验参数是否适用于这些函子，由std::is_invocable_v和SFINAE。
template<typename F, typename T, std::enable_if_t&l
浏览 3提问于2020-11-19得票数 1
回答已采纳
3回答
此时此刻，这让我抓狂了。作为一个自制练习，我想在一个类中创建一个递归调用模板。在.h文件中，我有：
template <typename T1>
class BinaryTree
{
public:
BinaryTree(T1 element);
~BinaryTree();
BinaryTree* addLeftLeaf(BinaryTree<T1>* node);
等等。
然后在.cpp中
template <typename T1> BinaryTree* BinaryTree&l
浏览 0提问于2012-01-19得票数 2
回答已采纳
1回答
的真正含义是什么？“函数模板的专业化不参与过载解析。只有基本模板才被认为是”“。
我用它的专用版本编写了一个简单的模板函数，可以看到它被称为“专门化”：
// Base template
template <typename T>
T max(T a, T b) {
std::cout << "Base Template" << std::endl;
return (a>b) ? a : b;
}
// Specialization for int
template<>
int max<int>
浏览 0提问于2020-02-04得票数 4
回答已采纳
2回答
在下面的代码中，我有一个非成员模板函数，并对一个类型的int完全专门化。
#include <iostream>
template <typename U>
void f(const U& x, const U& y)
{
std::cout << "generic " << x << " " << y << std::endl;
}
template <>
void f(const int& x, const int& y)
浏览 2提问于2019-04-29得票数 2
回答已采纳
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
回答已采纳
下面这段代码无法在gcc 4.5.3上编译
struct Frobnigator
{
template<typename T>
void foo();
template<typename T>
void bar();
};
template<typename T>
void Frobnigator::bar()
{
}
template<typename T>
void Frobnigator::foo()
{
bar<T>();
}
template<> //
浏览 1提问于2014-01-14得票数 24
回答已采纳
3回答
我有一个关于模板专门化的问题，我想了解一下。我正在使用Visual C++ 10.0 (2010)。我有一个这样的类：
class VariableManager
{
public:
template<typename VarT>
VarT get(std::string const& name) const
{
// Some code...
}
// This method supposed to be fully evaluated, linkable metho
浏览 0提问于2011-07-15得票数 9
回答已采纳
1回答
假设我有这个代码
template<typename T2, typename T = int>
struct X
{
static double f;
};
template<typename T>
double X<T>::f = 14.0;
如果我试图编译clang，请给我以下错误
嵌套名称说明符“X：：”用于声明不引用类、类模板或类模板部分专门化
对于GCC来说：
错误:非模板“double X：：F”的模板定义
问题是：
为什么编译器希望我们像这样专门化结构X：
template<typename T2>
st
浏览 0提问于2015-07-25得票数 5
回答已采纳
1回答
假设我们有以下几点：
template<typename T1, typename T2>
class A {}
template<typename T1, typename T2>
class A<T1*, T2*> {}
template<typename T>
class A<T, T> {}
现在，我知道我们需要选择最专业的类，但是对于A<double*，double*>，两个专业都有一个歧义错误，我的老师告诉我，他们的专业水平是相同的。但第一眼，我会说A<T，T>更专业。我们是如何得出这个结论的？
浏览 5提问于2022-05-24得票数 0
回答已采纳
1回答
这个问题是在的背景下提出的。
如我所料，这个翻译单位不编译：
template <int Num> int getNum() { return Num; }
template int getNum<0>();
template int getNum<0>(); // error: duplicate explicit instantiation of 'getNum<0>'
int main() { getNum<0>(); return 0; }
我理解这一点，我尝试过两次做同样的显式模板实例化。然而，事实证明，将
浏览 0提问于2018-10-05得票数 5
回答已采纳
考虑：
void f() {
return 5;
}
以上将引起错误。但为什么不这样？
template <typename = void> void f() {
return 0;
}
我正在和gcc一起编-4.5.1。为什么使用模板会使我不会因为执行与非模板函数相同的非法返回语句而收到错误呢？唯一的挫折是，如果不调用函数(即f())，就不能调用：
error: return-statement with a value, in function returning 'void'
但是，为什么我能够为一个空函数模板定义一个返回语句呢？
下面
浏览 0提问于2012-11-06得票数 4
回答已采纳
这是以下代码中已知的错误：
‘controlled_runge_kutta’不是类模板
在以下代码中：
template<
class ErrorStepper ,
class ErrorChecker ,
class Resizer
>
class controlled_runge_kutta< ErrorStepper , ErrorChecker , Resizer , explicit_error_stepper_tag >
{
public:
};
int main()
{
return 0;
}
我知道我为什么会犯这个错误。但我的问题是，在
浏览 1提问于2015-02-06得票数 1
回答已采纳
2回答
任何人都能告诉我这段代码到底是怎么回事？
#include <iostream>
class BBB {
public:
BBB() { std::cout << std::endl << "BBB()" << std::endl; }
~BBB() { std::cout << std::endl << "~BBB()" << std::endl; }
};
template<class T>
class AAA {
浏览 0提问于2011-02-28得票数 4
1回答
在模板过载解析方面，我遇到了一些有趣的行为，它在发布和调试构建之间存在差异。我希望能够理解编译器/链接器所使用的规则，这些规则使得编译器/链接器能够以这种方式运行。
我试着挖掘了一下，这就是我想出来的：
S.h
#pragma once
#include <cstdint>
#include <iostream>
enum class Enumeration : uint32_t {
A = 0,
B
};
struct S {
template<typename T>
bool func(Enumeration en) {
浏览 3提问于2021-03-23得票数 1
回答已采纳
为什么在试图为显式模板专门化设置不同的返回值而不是auto时会出现编译错误？为什么在这里编译错误：
template <size_t T>
auto Get() = delete;
template <>
auto Get<0>(){
return 5;
}
std::string str = "Hello world!";
template <>
std::string const & Get<1>() {
return str;
}
int main() {
func_emp
浏览 6提问于2022-12-01得票数 0
1回答
为什么要对类型使用函数模板的显式实例化？如果我不使用函数的显式实例化，模板将用于创建必要的函数，那么显式实例化的用法是什么？
template <class Any>
void Swap (Any &, Any &);
// template prototype
template <> void Swap<job>(job &, job &);
// explicit specialization for job
int main(void)
{
template void Swap<char>(char &
浏览 1提问于2013-03-01得票数 0
2回答
C++标准禁止部分专门化的朋友声明。(第14.5.3/8节)：
友人声明不应声明部分专门化。[例子：
template<class T> class A { };
class X {
template <class T> friend class A<T*>; //error
};
-最终例子]
其他问题，如，已经收到了援引这一禁令的答案，但我想知道理由。我看不见它，也找不到我最喜欢的搜索引擎。然而，我可以发现，它可以直接回到C++98标准，因此，其基本原理大概是非常基本和明确的。有人能给我解释一下吗？
浏览 1提问于2013-05-15得票数 17
我使用CRT模式，并希望基类从派生类中看到typedefs。在 @James McNellis中，McNellis建议使用base_traits类来实现这一点，而且效果很好。但是在那篇文章中描述的情况下，派生类本身就是一个模板。当派生类不是模板时，这种方法在VS2010中不起作用。
template <class D>
struct base_traits;
template <class D>
struct base
{
typedef typename base_traits<D>::value_t value_t;
};
struct der
浏览 1提问于2014-09-04得票数 2
回答已采纳
3回答
让我们拿一些具体的东西：
#include <utility>
#include <vector>
template <typename ... Ts>
using void_t = void;
template <typename T, typename = void_t<>>
struct is_lt_comparable : std::false_type {};
template <typename T>
struct is_lt_comparable<T, void_t<decltype(std
浏览 3提问于2018-01-01得票数 1
回答已采纳
1回答
我怀疑gcc 4.8.3是否插入了错误的模板函数.此问题不发生在调试模式中，而是仅在优化模式下发生。然而，这发生在一个复杂的代码库中，我无法在一个简单的测试用例中重现这个问题。
我的代码如下所示
#include "stdio.h"
class A {
public:
template<typename T> int WriteNative(const T) {
printf("here?\n")
return 0;
}
template<typename D>
浏览 1提问于2017-05-03得票数 0
3回答
我想知道是否有人知道为什么下面两段代码的行为非常不同。我能理解为什么第二个不能工作，但为什么第一个工作？在同一个地方，int x = gc.f();模板应该被实例化，这样同样的错误就会发生，但是为什么实际上没有错误呢？
a.cpp
#include <iostream>
using namespace std;
template <typename T>
struct A {
struct B {
};
};
template <typename T>
struct C {
typedef A<C<T> >
浏览 4提问于2012-02-29得票数 4
回答已采纳
我正试图找到一种简单的方法(使用预C++11，即不使用decltype)来记录模板对类型的哪些要求才能正常工作。也许有更好的方法来做这件事。不过，我的问题是：
#include <iostream>
template <typename T> struct Foo {
static const int test = sizeof(T::size);
};
template <typename T> struct DetectAndError {
DetectAndError() { int test = sizeof(T::size);
浏览 2提问于2016-11-02得票数 3
回答已采纳
为什么使用std::queue容器创建std::vector不会引发编译器错误？
只有当pop被调用时才会发生编译器错误(这很明显，因为向量不提供pop_front())。
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
int main()
{
queue<int, vector<int>> s;
s.push(10);
cout << s.front() << endl;
浏览 4提问于2015-08-15得票数 4
回答已采纳
2回答
我看到了一件有趣的事情，但我不明白为什么。
template<class dataType>
Class A
{
AFnc();
}
template<> A<int>::AFnc() { }
只使用专门的模板会产生一个错误，说明同一函数有多个定义。它说它是在同一个地方产生的。但如果我加上
template<class dataType>
A<dataType>::AFnc()
{
}
然后它就会摆脱这个错误。
为什么？有没有人能解释一下这种行为。
浏览 0提问于2013-07-11得票数 2
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
