部分模板实例化
是指在软件开发中，使用模板来创建对象的过程中，只实例化模板的一部分内容，而不是完全实例化整个模板。这种方式可以根据具体需求灵活地选择实例化的部分，从而提高代码的复用性和灵活性。
在前端开发中，部分模板实例化可以用于创建可复用的UI组件。通过定义一个通用的模板，然后根据不同的需求实例化其中的一部分内容，可以快速构建出各种不同样式和功能的UI组件，提高开发效率。
在后端开发中，部分模板实例化可以用于创建可复用的业务逻辑。通过定义一个通用的模板，然后根据不同的业务需求实例化其中的一部分内容，可以快速构建出各种不同功能的业务逻辑，提高代码的复用性和可维护性。
在软件测试中，部分模板实例化可以用于创建测试用例。通过定义一个通用的测试模板，然后根据不同的测试场景实例化其中的一部分内容，可以快速生成各种不同的测试用例，提高测试覆盖率和测试效率。
在数据库中，部分模板实例化可以用于创建数据库表结构。通过定义一个通用的表结构模板，然后根据不同的业务需求实例化其中的一部分内容，可以快速创建出各种不同的表结构，提高数据库的灵活性和扩展性。
在服务器运维中，部分模板实例化可以用于创建服务器配置。通过定义一个通用的服务器配置模板，然后根据不同的应用需求实例化其中的一部分内容，可以快速配置出各种不同的服务器环境，提高服务器的可管理性和可扩展性。
在云原生应用开发中，部分模板实例化可以用于创建容器化应用。通过定义一个通用的容器模板，然后根据不同的应用需求实例化其中的一部分内容，可以快速构建出各种不同的容器化应用，提高应用的可移植性和可扩展性。
在网络通信中，部分模板实例化可以用于创建通信协议。通过定义一个通用的协议模板，然后根据不同的通信需求实例化其中的一部分内容，可以快速定义出各种不同的通信协议，提高通信的灵活性和可扩展性。
在网络安全中，部分模板实例化可以用于创建安全策略。通过定义一个通用的安全策略模板，然后根据不同的安全需求实例化其中的一部分内容，可以快速配置出各种不同的安全策略，提高系统的安全性和可靠性。
在音视频处理中，部分模板实例化可以用于创建音视频处理流程。通过定义一个通用的处理流程模板，然后根据不同的处理需求实例化其中的一部分内容，可以快速构建出各种不同的音视频处理流程，提高处理效率和质量。
在人工智能中，部分模板实例化可以用于创建机器学习模型。通过定义一个通用的模型模板，然后根据不同的学习任务实例化其中的一部分内容，可以快速构建出各种不同的机器学习模型，提高模型的准确性和泛化能力。
在物联网中，部分模板实例化可以用于创建物联网设备。通过定义一个通用的设备模板，然后根据不同的设备类型实例化其中的一部分内容，可以快速生产出各种不同的物联网设备，提高设备的互操作性和可扩展性。
在移动开发中，部分模板实例化可以用于创建移动应用界面。通过定义一个通用的界面模板，然后根据不同的应用需求实例化其中的一部分内容，可以快速构建出各种不同样式和功能的移动应用界面，提高开发效率和用户体验。
在存储中，部分模板实例化可以用于创建存储方案。通过定义一个通用的存储模板，然后根据不同的存储需求实例化其中的一部分内容，可以快速配置出各种不同的存储方案，提高数据的可靠性和可扩展性。
在区块链中，部分模板实例化可以用于创建智能合约。通过定义一个通用的合约模板，然后根据不同的业务需求实例化其中的一部分内容，可以快速构建出各种不同的智能合约，提高合约的可编程性和安全性。
在元宇宙中，部分模板实例化可以用于创建虚拟世界。通过定义一个通用的世界模板，然后根据不同的虚拟场景实例化其中的一部分内容，可以快速构建出各种不同的虚拟世界，提高用户的沉浸感和交互性。
腾讯云相关产品和产品介绍链接地址：
- 云开发：提供全栈云开发能力，包括云函数、云数据库、云存储等，支持前端开发、后端开发、数据库、存储等多个领域。
- 云原生应用引擎：提供容器化应用的部署和管理服务，支持快速构建和扩展云原生应用。
- 云服务器：提供弹性计算能力，支持自定义配置和管理云服务器实例。
- 云数据库：提供高性能、可扩展的数据库服务，支持多种数据库引擎和存储引擎。
- 云存储：提供安全可靠的对象存储服务，支持海量数据存储和访问。
- 人工智能：提供丰富的人工智能服务，包括图像识别、语音识别、自然语言处理等。
- 物联网：提供全面的物联网解决方案，包括设备接入、数据管理、应用开发等。
- 移动开发：提供移动应用开发的工具和服务，支持多平台开发和一体化部署。
- 区块链：提供安全可信的区块链服务，支持快速构建和部署区块链应用。
- 音视频处理：提供高效稳定的音视频处理服务，支持转码、剪辑、直播等多种处理操作。
- 网络安全：提供全面的网络安全解决方案，包括防火墙、入侵检测、漏洞扫描等。
- 存储：提供高性能、可扩展的文件存储服务，支持多种存储协议和访问方式。
请注意，以上仅为腾讯云相关产品的示例，其他厂商的类似产品也可以根据具体需求进行选择。
相关·内容
std::remove_reference使用以下实现：
template< class T > struct remove_reference {typedef T type;};
template< class T > struct remove_reference<T&> {typedef T type;};
template< class T > struct remove_reference<T&&> {typedef T type;};
因此，如果使用std::remove_refere
浏览 6提问于2014-07-25得票数 0
回答已采纳
1回答
在编写一个供个人使用的小型模板元编程库时，我遇到了一个有趣的问题。
由于我对一些元功能重用了一些部分专门化，所以我决定将它们放在一个公共模板类下，并使用标记和嵌套的部分专门化来提供行为上的差异。
问题是我得到了(对我来说)毫无意义的结果。下面是一个很小的例子，展示了我想要做的事情：
#include <iostream>
#include <cxxabi.h>
#include <typeinfo>
template <typename T>
const char * type_name()
{
return abi::__cxa_de
浏览 1提问于2015-07-13得票数 24
回答已采纳
1回答
我不明白为什么标准首先为模板定义模板实例化，如下所示：N3797::14.7/4 [temp.spec]
实例化函数、类、类模板的成员或成员模板的行为称为模板实例化。
但是在任何地方，它都使用专门化的实例，如下面的N3797::14.7/4 [temp.spec]
实例化模板专门化可以对给定的参数列表隐式实例化(14.7.1)，也可以显式实例化(14.7.2)。
我不明白这点。模板本身是一个与模板规格不同的概念，模板规格可以是explicit specialization或partial specialization。例如，N3797::14.5.5/1 [temp.class
浏览 1提问于2015-02-26得票数 2
回答已采纳
2回答
在这一章中，N3797::14/4 [temp] (强调地雷)
模板名称具有链接(3.5)。非成员函数模板可以具有内部链接；任何其他模板名称都应具有外部链接。具有内部链接的模板的专门化(显式或隐式)不同于其他翻译单元中的所有专门化。
提到了内隐专业化。据我从上下文中了解到，这个概念与模板显式专门化不同，后者具有
template < >声明
语法。因此，我猜想隐式专门化与部分类模板专门化有关。不幸的是，我无法在当前工作草案中定义隐含的专门化概念。
浏览 4提问于2015-02-23得票数 1
回答已采纳
基于策略的类的根是一个容器适配器，它为不同容器之间的转换提供了接口。它被一个类型T和模板模板参数容器参数化。为了使它与标准容器一起工作，我需要部分地应用它们的一些参数，例如分配器或数组大小。我就是这样做的：
template< typename T >
struct vector_{
using policy = std::vector<T>; //default allocator
};
或者在给我带来麻烦的情况下：
//data_adapter expects template template parameter that takes one type-a
浏览 3提问于2014-08-25得票数 1
回答已采纳
下面的代码是如何检测两个类是否相同的？特别是我没有理解第二个IsSame类的语法。它看起来不像是显式的初始化。请让我知道我应该通过哪个链接来理解这一点？我正在阅读罗伯特希尔迪特的书“C++ the complete reference”。
template<typename A, typename B> struct IsSame {
static const bool same = false;
};
template<typename A> struct IsSame<A, A> {//have confusion here
static
浏览 0提问于2018-02-08得票数 1
1回答
我们是否可以显式地部分实例化C++模板？
template class <typename T, int N>
class MyClass {
...
};
template<int N> class MyClass<int, N>; // not meant for specification
template<int N> class MyClass<float, N>;
就像我们可以拥有：
template class <typename T>
class MyClass {
...
};
templa
浏览 0提问于2016-08-11得票数 3
回答已采纳
在这里，“非依赖”的意思是“不依赖于该特定函数模板的任何其他模板参数”。
在回答时，我以为我找到了答案，但根据@Johannes (在对我的答案的评论中)，我误解了这里的标准。以以下简单的例子为例：
#include <type_traits>
template<class T>
struct X{
template<class U = typename T::type>
static void foo(int){}
static void foo(...){}
};
int main(){
X<std::enable_if<
浏览 3提问于2013-03-06得票数 11
下面的代码给出了预期的编译器错误()：
1 template<bool> struct Range;
2
3 template<int value, typename = Range<true> > struct Unique;
4 template<int value> struct Unique<value, Range<(value > 1)> > { typedef char type[1]; };
5 template<int value> struct Unique<
浏览 1提问于2012-03-06得票数 6
回答已采纳
1回答
考虑中的以下示例
//Translation unit #1:
export module stuff;
export template<typename T, typename U> void foo(T, U u) { auto v = u; }
export template<typename T, typename U> void bar(T, U u) { auto v = *u; }
//Translation unit #2:
export module M1;
import "defn.h"; // provide
浏览 2提问于2021-09-29得票数 8
我有以下代码：
template <class T, class U = T>
class A {
public:
void f();
};
template <class T>
class A<T, T> {
public:
void f(); // Unaltered method.
// Some differences.
};
template <class T, class U>
void A<T, U>::f() {}
int main() {
A<int> a;
浏览 2提问于2014-01-08得票数 7
1回答
带有条件no以外和重载的不一致
、、、、
我有一个非常类似于 1的问题。
简而言之，我有一个magic方法，如果另一个方法是noexcept，它就是noexcept。
奇怪的是，这个“另一个方法”有两个重载，编译器选择第二个重载来确定magic noexcept-ness。
但是，当稍后调用magic时，将调用第一次重载，但是magic的noexcept-ness仍然是一样的！
这是魔杖盒
据我所知：
noexcept(magic(dummy2{}))调用
noexcept(noexcept(adl_caller(...))，返回到
adl_caller(..., priority_tag<0>) noexce
浏览 4提问于2017-05-03得票数 9
回答已采纳
2回答
C++11翻译阶段8混淆
、、、
第七阶段:分隔令牌的空白字符不再重要。每个预处理令牌被转换为令牌。生成的标记在语法和语义上进行分析，并作为翻译单元进行翻译。
第8阶段:翻译单元和实例化单元合并如下:对每个翻译单元进行检查，以生成所需实例化的列表。所需模板的定义位于。这是实现-定义了是否需要包含这些定义的翻译单元的来源。所有所需的实例化都是为了产生实例化单元而执行的。注意:它们与翻译单位相似，但不包含对未实例化模板的引用，也不包含模板定义。-end注意，如果任何实例化失败，则程序的格式不正确。
我已经删除了一些笔记，以缩短粘贴的文本。
为什么模板在翻译单元已经翻译到C++的编译阶段8之后才执行定位和实例化呢?考虑到两个
浏览 5提问于2012-09-30得票数 2
回答已采纳
这是来自ISO C++标准14.6.4.1实例化点的语句。
对于函数模板专门化、成员函数模板专门化或类模板的成员函数或静态数据成员的专门化，如果专门化是隐式实例化的，因为它是从另一个模板专门化中引用的，并且引用它的上下文取决于模板参数，则专门化的实例化点是封闭专门化的实例化点。否则，这种专门化的实例化点将紧跟引用该专门化的命名空间范围声明或定义。
如果以使用函数模板或成员函数的默认参数定义的方式调用类模板的函数模板或成员函数，则默认参数的实例化点是函数模板或成员函数专门化的实例化点。
对于类模板专门化、类成员模板专门化或类模板类成员的专门化，如果专门化是隐式实例化的，因为它
浏览 1提问于2010-09-28得票数 5
回答已采纳
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
回答已采纳
n4567 temp.class.spec.matchp2
如果可以从实际模板参数列表(14.8.2)推导出部分专门化的模板参数，则部分专门化与给定的实际模板参数列表匹配。
template<class T, class U>
struct S{};
template<class U>
struct S<int, U>{};
S<char, int> s;
我知道部分专门化S<int, U>与实际的模板参数列表char, int不匹配，第二个参数U可以根据14.8.2.5从int中推导出来。
但我不知道14.8.2中哪些规
浏览 1提问于2016-01-11得票数 3
回答已采纳
我正在写一些关于Partial template specialization.What的东西，我想做的是使用一个模板is_valid来检查这个类是否有一个名为valid的成员类型。源码如下。 #include <iostream>
class A {
public:
typedef void valid;
};
class B {
public:
typedef int valid;
};
class C {
};
template <typename T, typename U = void> struct is_valid
{
c
浏览 71提问于2021-08-13得票数 3
回答已采纳
2回答
template<typename T, typename U = T>
struct Test{};
template<typename T>
void func(Test<T>){ //#1
}
int main(){
func(Test<int>{}); //#2
}
在标准中似乎没有提到模板参数所需的默认参数的情况。
在中
如果参数声明中指定了初始化器-子句，则此初始化-子句将用作默认参数。默认参数将用于调用，其中尾随参数缺少。
在本节中，规则明确描述何时为函数调用提供默认参数。但是，我还没有在标准中找到类似于上面描述何时
浏览 2提问于2020-07-13得票数 5
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回答
是否总是省略模板实例化
、、、、
这个模板函数f<X>()是否总是不被实例化？
if constexpr(something false){
//some template function OR function in template class
f<X>();
}
下面是我的测试()。
我创建了fun<S>()，它将实例化E<S>当且仅当S!=void。
然后我给fun<void>()，fun<int>()和fun<float>()打电话。
我认为if constexpr(false)迫使C++编译器跳过fun<
浏览 0提问于2019-05-28得票数 3
回答已采纳
2回答
模板中定义的朋友函数的实例化
、、、、
这是的后续行动。最初的案例是另一回事，但在我写了一个糟糕的答案和OP澄清的过程中，我们可能需要一个语言律师的帮助来理解正在发生的事情。
在C++中的思考-实用编程第2卷-您可以找到以下示例( Thinking，online )：
//: C05:FriendScope3.cpp {-bor} // Microsoft:使用-Za (与ANSI兼容的)选项#包括使用命名空间std；模板类友好{T t；public: Friendly(const T& theT)：t(theT) {} friend void f(const Friend&fo){ cout << f
浏览 6提问于2021-04-28得票数 3
回答已采纳
1回答
考虑以下代码：
template <class x1, class x2 = int*>
struct CoreTemplate { };
template <class x1, class x2>
struct CoreTemplate<x1*, x2*> { int spec; CoreTemplate() { spec = 1; } };
template <class x>
struct CoreTemplate<x*> { int spec; CoreTemplate() { spec = 3; } };
int ma
浏览 0提问于2012-06-22得票数 3
回答已采纳
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回答
很抱歉有这么多不重要的代码(也在上)
#include <memory>
#include <cstdio>
template< typename T, size_t N, typename ... Args >
void test_1 ( Args ... args)
{
using namespace std;
if constexpr( 1 > (sizeof... (args)) ) {
return;
}
else
{
auto arg_list [[mayb
浏览 0提问于2018-07-26得票数 10
unique_ptr有一个选项可以选择数组类型--稍后使用正确的删除器(带有数组delete[])：
std::unique_ptr<std::string[]> up(new std::string[10]); // OK
unique_ptr类本身的定义包括这种类型的专门化(注意，T[]大括号靠近定义本身)：
template<typename T, typename D>
class unique_ptr<T[], D> { ... }
但是，它不是string[]或int[]本身是一个类型，所以应该按照定义将其模板化为T类型，而不是T[]？换句话说，
浏览 0提问于2015-09-14得票数 1
回答已采纳
3回答
#include <iostream>
#include <utility>
template <class T> struct is_rvalue_ref : std::false_type {};
template <class T> struct is_rvalue_ref<T&&> : std::true_type {};
template <typename T> bool is_rvalue_ref_func(T){return false;}
template <typen
浏览 6提问于2015-02-14得票数 0
回答已采纳
2回答
#如果与警察对抗
、、、
哪一个更适合编译时配置(例如调试/发布)、预处理指令或if constexpr。
#define DBG
#if DBG
// some code
#endif
// --------------------------------- or
inline constexpr bool DEBUG { true };
if constexpr ( DEBUG )
{
// some code
}
浏览 7提问于2022-04-08得票数 3
回答已采纳
没有参数的模板类意味着什么？例如，让我们使用一个计算阶乘的模板类，它的模板参数在N- N!中。
基本上，这是一门课：
template <int N> class Factorial
{
public:
enum {fact = N * Factorial<N-1>::fact};
};
但是，我发现这个班有一个“扩展类”，
template<> class Factorial<1>
{
public:
enum {fact = 1};
};
在这里，我的问题是:没有参数的模板意味着什么，template<>？
提前谢
浏览 1提问于2013-08-01得票数 9
回答已采纳
2回答
我对模板元编程很陌生。在研究它时，我遇到了一个小代码块，它决定了编译时的类型。我的问题是，这个类型的人在这里是如何工作的。程序执行的顺序是什么？
#include <iostream>
using namespace std;
template <bool condition, class Then, class Else>
struct IF
{
typedef Then RET;
};
template <class Then, class Else>
struct IF<false, Then, Else>
{
typ
浏览 0提问于2014-08-17得票数 0
回答已采纳
1回答
今天，我错误地编写了下面的代码：
template<int V>
typename std::enable_if<(V > 0)>::type
Test() {
Test<V - 1>();
}
template<int V>
typename std::enable_if<(V == 0)>::type
Test() {
std::cout << "0" << std::endl;
}
int main() {
Test<1>();
}
编译器错误了我的那个n
浏览 0提问于2020-09-30得票数 4
回答已采纳
2回答
template <typename T, typename = void>
struct IsIterable : std::false_type {};
template <typename T>
struct IsIterable<
T,
decltype(
std::begin(std::declval<std::add_lvalue_reference_t<T>>()),
std::end(std::declval<std::add_lvalu
浏览 0提问于2015-01-10得票数 2
回答已采纳
让我们举个例子：
template<typename T> struct foo
{
template<typename X> void bar(void (T::*)()) {}
template<typename X> void bar(X*) {}
template<typename X> void bar(T**) {}
};
int main() { foo<int> p; }
上面的class foo<int>实例化会不会实例化成员模板声明 bar，即使成员本身就是模板？如有任何标准参
浏览 1提问于2016-01-19得票数 2
回答已采纳
1回答
我有一些关于下一个代码的问题：
template<typename T>
class Base;
template<typename T, typename P>
class Base<T(P)> {
};
template<typename T>
class Derived;
template<typename T, typename P>
class Derived<T(P)> : public Base<T(P)> {
};
类专门化Derived<T(P)>在将类专门化Derive
浏览 54提问于2019-05-30得票数 2
回答已采纳
1回答
成员函数只要被调用就会被实例化，还是在程序中只实例化一次？
#include<iostream>
using namespace std;
template<typename T>
class test {
public:
test();
void test_function_1(int iv = 0);
void Print(void) const;
private:
T date;
};
template<typename T> test<T>::test()
{
date = 0;
}
temp
浏览 3提问于2020-09-30得票数 0
2回答
struct Value {
using a_type = int;
a_type f() { return 1; }
};
template<typename T>
struct Wrapper {
T t;
auto call_f() { return t.f(); }
};
int main() {
Wrapper<Value> w;
Wrapper<int> w2;
w.call_f();
}
这是很好的关于Clang和GCC的。Wrapper<int>被实例化，即使不能推断Wr
浏览 5提问于2016-08-08得票数 4
回答已采纳
直到最近，我才编写了许多C++模板，但我正试图深入研究它们。修复一个开发人员的代码，我成功地产生了一些我无法解释的编译器行为。这是简化的程序。(当我试图简化的时候，我就失去了那种“奇怪”的行为)。让我们考虑一些类Depender，它是一个模板结构依赖的参数。Depender可以依赖于Dependee的列表。我有一些宏可以产生Dependency模板的专门化。以下代码块中的点表示可能的宏展开。我在dots之前有一个forward-declared MainDependee，在dots之后有MainDependee的定义。
#include <type_traits>
templat
浏览 15提问于2022-11-03得票数 0
回答已采纳
我对下面的代码感兴趣，并想知道这个语法的名称是什么。
//Define a class template
template <class T>
class my_unique_ptr{}
//What is this?
template <class T>
class my_unique_ptr<T[]>{}
完整的示例可以在这里找到
我知道这段代码的执行结果，但不知道语法是什么。我试过搜索，但没有找到任何结果。它看起来像一个显式的专门化，但是没有公共的头template<>。语法看起来也像一个函数重载，但它适用于一个类。如有任何建议，将不胜感
浏览 2提问于2020-09-26得票数 0
回答已采纳
3回答
如果我们考虑函数模板重载，C++中的标准行为是首先选择“最专门的”重载(从基本模板中选择)。下一步是查看所选的重载是否显式地专门化。如果是，则将选择匹配的显式专门化。。
您能否指出标准中定义第二步的位置(上一段中突出显示的部分)？
谢谢。
浏览 0提问于2018-09-11得票数 1
如果没有使用静态成员，则是否在模板类中初始化静态成员变量？我用它来注册类型。
template<class T>
class A
{
static bool d;
};
template<class T> bool A<T>::d = [](){regist<A<T>>(); return true;}();
int main()
{
A<int> a;
return 0;
}
我找到一种方法来测试它。它打印1，而不是2。regist()不是名为abd，静态成员没有初始化。我的测试在VC110编译器
浏览 2提问于2013-10-13得票数 3
3回答
我有以下4个文件：
arrayListType.h：将arrayListType类声明并定义为从arrayListType类继承的模板unorderedArrayListType.h：，并将unorderedArrayListType定义为模板。main1.cpp：测试程序来测试unorderedArrayListType类。Makefile
在访问arrayListType在unorderedArrayListType中的受保护变量时，我遇到了一个编译错误，例如："length未在此作用域中声明“，"list未在此作用域中声明”，其中length和list是arrayList
浏览 7提问于2011-07-06得票数 49
回答已采纳
1回答
函数模板显式实例化
、、、
我有一个函数，它对许多基本类型都有完全相同的代码。为了节省代码行，我想将它声明为模板，并为以后使用的所有类型显式实例化它一次:头文件中的声明和实现+ cpp文件中的显式实例化(与编写普通函数bibs相同的设计)。
我的做法是：
// header.h
template <class T> T func (T arg);
// header.cpp
#include "header.h"
template <class T> T func (T arg)
{
// implementation...
}
template int func&l
浏览 3提问于2014-02-03得票数 2
1回答
我想要一个只为某些类型定义的模板化函数，所以我写道：
/* --- header file with just a declaration --- */
template<class T>
void myFunction(T arg);
/* --- cpp file with specialized definition --- */
template<>
void myFunction<int>(int arg){
// mybody
}
但我有点困惑，比如通读。头文件中的声明是否足够好，以便链接器始终链接到相同的专门化(静态链接)？或者我需要
浏览 0提问于2018-09-27得票数 0
1回答
为什么&&严格的编译时间？
、、、、
我正在试验基本的模板元编程。我尝试实现结构模板，帮助我们确定它们的模板参数是否是素数。即：
template<int N, int D>
struct IsPrime_Descend {
const static bool val = (N % D != 0) && IsPrime_Descend<N, D - 1>::val;
};
template<int N>
struct IsPrime_Descend<N, 1> {
const static bool val = true;
};
template
浏览 4提问于2022-01-29得票数 1
回答已采纳
下面的最小代码给出了一个编译错误：
#include <iostream>
#include <functional>
using namespace std;
template<typename ActionType, typename... Cols>
void print_action(function<ActionType*(Cols..., ActionType)> action_factory)
{
}
int main(int argc, char *argv[])
{
print_action<string,
浏览 4提问于2016-01-07得票数 2
1回答
(对不起，标题太乱了。我很乐意接受改进的建议。
我会尽量直截了当。我有民俗密码：
file1.hpp
template <class val_t>
struct MatOps;
文件2.：
#include "file1.hpp"
template <> struct MatOps<float>{
static void method1(){
// Do something
}
static void method2(){
// Do something
}
static void method3(){
浏览 4提问于2018-05-14得票数 1
回答已采纳
我有点使用静态多态，我调用一个函数，它根据初始参数的类型在内部调用“右”专用函数(基本上我在做标记)。以下是代码：
#include <iostream>
using namespace std;
// tags
struct tag1{};
struct tag2{};
// the compliant types, all should typedef tag_type
struct my_type1
{
using tag_type = tag1;
};
struct my_type2
{
using tag_type = tag2;
};
//
浏览 7提问于2014-08-07得票数 15
回答已采纳
1回答
我对C++模板没有太多的经验，所以我的术语可能已经过时了。请耐心等待，欢迎指正。
我有通用类型的fixed_buf<N>
// in foo.h
template <int N>
class fixed_buf {
private:
unsigned char data[N];
public:
const unsigned char* begin() const {
return std::begin(data);
}
const unsigned char* end() const {
return std::end(data);
浏览 1提问于2019-04-18得票数 1
回答已采纳
2回答
考虑下面的小代码片段：
#include <iostream>
template<class T>
int test();
int main()
{
std::cout << test<int>() << "\n";
}
// POI for test<int>() should be right here
template<class T>
int test()
{
return 0;
}
，为Clang和g++
浏览 5提问于2014-04-12得票数 13
回答已采纳
我想问一种我所理解的非常糟糕的C++编程形式的边缘情况，并且很可能永远不会在实践中使用。但是，我想确保我完全理解模板语法。
我的问题只涉及模板专门化中模板参数的反转。下面是示例代码，最简洁地说明了我的问题：
#include <iostream>
template<typename T1, typename T2>
class A
{
public:
int foo()
{
return 1;
}
};
template<typename T1, typename T2>
class A<T2, T1>
浏览 1提问于2012-06-17得票数 2
回答已采纳
2回答
目前，我正在从事一个C++项目，我计划在其中嵌入Lua脚本。由于这个原因，需要将某些类导出到Lua，并且我希望使其更方便，因此我创建了一个模板类：
template <class T>
class ExportToLua {
public:
ExportToLua() {}
~ExportToLua() {}
private:
static int m_registered;
};
template <class T> int ExportToLua<T>::m_registered = T::
浏览 2提问于2013-09-02得票数 6
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
