是否可以组合部分模板专门化来生成隐式生成的共享代码路径？
是的，可以通过组合部分模板专门化来生成隐式生成的共享代码路径。这种方法可以提高代码的复用性和开发效率。
隐式生成的共享代码路径是指通过模板化的方式生成代码，而不是手动编写每个代码路径。通过定义一些通用的模板，可以根据具体的需求来生成特定的代码路径。
这种方法的优势在于可以减少重复劳动，提高开发效率。通过模板化的方式，可以快速生成符合要求的代码，减少了手动编写的时间和错误的可能性。
应用场景包括但不限于：快速生成相似功能的代码、批量生成特定类型的代码、自动生成测试用例等。
腾讯云提供了一些相关的产品和服务，例如：
- 云开发（CloudBase）：提供了一站式的云端研发平台，包括前后端开发、数据库、存储、部署等功能，可以帮助开发者快速构建应用。
- 云函数（SCF）：无服务器计算服务，可以根据事件触发自动运行代码，适用于处理后台任务、定时任务等场景。
- 云原生应用平台（TKE）：提供了容器化的部署和管理服务，可以帮助开发者快速构建和管理云原生应用。
以上是腾讯云的一些相关产品和服务，更多详细信息可以参考腾讯云官方网站：https://cloud.tencent.com/
相关·内容
2回答
在这一章中，N3797::14/4 [temp] (强调地雷)
模板名称具有链接(3.5)。非成员函数模板可以具有内部链接；任何其他模板名称都应具有外部链接。具有内部链接的模板的专门化(显式或隐式)不同于其他翻译单元中的所有专门化。
提到了内隐专业化。据我从上下文中了解到，这个概念与模板显式专门化不同，后者具有
template < >声明
语法。因此，我猜想隐式专门化与部分类模板专门化有关。不幸的是，我无法在当前工作草案中定义隐含的专门化概念。
浏览 4提问于2015-02-23得票数 1
回答已采纳
2回答
模板类规范和继承
、、、、
template<typename T>
class CommonBase
{
};
template<typename T>
class Base : public CommonBase<T>
{
protected:
bool flag;
};
template<>
class Base<int> : public CommonBase<int>
{
Base() {flag = false;}
};
会导致"flag未在命名空间中声明“的错误。我哪里做错了？
浏览 3提问于2019-07-16得票数 2
如果没有使用静态成员，则是否在模板类中初始化静态成员变量？我用它来注册类型。
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
1回答
这一问题较为理论性，其范围不同于：
-解释编译器甚至在查看专门化之前就会执行重载解析。
-描述这两种机制之间的差异
让我们进入理论问题：
template <typename T>
T add(T a, T b)
{
return a + b;
}
template <>
int add<int>(int a, int b)
{
return a + b; //Specialization
}
int add(int a, int b)
{
return a + b; //Overloading
}
add(3,4); //
浏览 3提问于2020-05-10得票数 2
1回答
在编写一个供个人使用的小型模板元编程库时，我遇到了一个有趣的问题。
由于我对一些元功能重用了一些部分专门化，所以我决定将它们放在一个公共模板类下，并使用标记和嵌套的部分专门化来提供行为上的差异。
问题是我得到了(对我来说)毫无意义的结果。下面是一个很小的例子，展示了我想要做的事情：
#include <iostream>
#include <cxxabi.h>
#include <typeinfo>
template <typename T>
const char * type_name()
{
return abi::__cxa_de
浏览 1提问于2015-07-13得票数 24
回答已采纳
2回答
我有一些具有同名子类型的类型，每种类型：
struct TypeA {
typedef int subtype;
};
struct TypeB {
typedef float subtype;
};
也包括没有此子类型但在相同上下文中使用的类型：
struct TypeC {
// (no subtype defined)
};
如何添加一个提供自定义编译错误消息的虚拟子类型？
我(迄今未成功)的尝试是：
struct TypeC {
struct subtype {
static_assert(false, "Attempt to a
浏览 3提问于2014-06-25得票数 5
回答已采纳
1回答
朋友模板函数规范
、、
我有一个与模板运算符>>建立友谊的类：
class MyInputStream
{
...
private:
std::istream& impl;
template<class T>
friend MyInputStream& operator>> (MyInputStream& stream, T& outParam);
}
现在我定义操作符>>
template<class T>
MyInputStream& operator>> (MyIn
浏览 1提问于2014-09-11得票数 0
回答已采纳
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
让我们举个例子：
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回答
我想要一个只为某些类型定义的模板化函数，所以我写道：
/* --- 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
2回答
取决于我是用-O3编译还是没有优化，编译器没有选择相同的函数模板实例化。使用gcc (Debian 8.3.0-6) 8.3.0。
由于疏忽，函数模板声明中有一个默认实现：
#pragma once
#include <iostream>
template <int>
void func() { std::cerr << "default impl\n"; } // normally no impl here
他们的专长是：
#include "func.h"
template <>
void func<
浏览 0提问于2019-07-03得票数 10
回答已采纳
当我用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回答
以下是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
回答已采纳
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回答
gcc找不到模板专门化
、、、
我的网络代码使用模板专门化来序列化不能简单复制的类型。我定义了一个通用模板
template<typename T> struct TypeHandler
它处理可以通过简单memcpy传输的所有类型，然后为所有其他类型定义专门化。现在的问题是，我有一个具有多个这样的专门化的文件，如果我用Visual编译代码，一切都很好。但是对于gcc，该文件中的所有模板专门化都会被使用，只有
template<> struct TypeHandler<uint32_t>
哪个变量长度编码整数以节省空间。
所有TypeHandler版本的名称空间都是相同的，甚至在同一个文件
浏览 3提问于2014-07-10得票数 2
2回答
我知道编译器不会实例化未使用的模板函数，只要它们在类中不是虚拟的。
在一个简单的例子中，如果我有两个重载的模板函数，它们都使用相同的模板参数，那么编译器似乎会实例化这两个重载。我想这是必需的，这样编译器才能执行过载解析？重载是否免于函数模板的延迟实例化规则？我无法在标准中找到相关的文本。下面是一个示例：
template<typename T>
void foo(T) {zzz}
template<typename T>
void foo(T*) {}
int main()
{
int* blah;
foo(blah);
}
如果没有实例化第一个重载
浏览 4提问于2014-11-19得票数 2
回答已采纳
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
在研究列表初始化的各种规则时，我在中发现了这一点。
否则，如果T是std::initializer_list<E>的专门化，则按下面的说明构造该对象。
另一方面，在std::initializer_list的概要中，在中，我发现了以下声明：
如果声明了initializer_list的显式专门化或部分专门化，则程序的格式不正确.
这些似乎是自相矛盾的说法，所以我误解了什么呢？
浏览 4提问于2020-05-25得票数 1
回答已采纳
我知道模板类的普通成员函数在第一次使用时会被实例化。但对于虚成员函数不能这样做，因为它可以通过基类指针访问。这是否意味着一旦模板类被实例化，虚拟成员函数就会被实例化？若否，何时？
浏览 0提问于2010-08-14得票数 4
回答已采纳
1回答
显式专业化认证是模板吗？
、、、
根据的说法，专门化是一个类/函数/...实例化的或显式专门化的。指出，一些显式专门化是模板，这使我相信显式专门化是专门化(在“从模板生成的实体”意义上)，而不是模板(有时)。
我的问题是，显式的特殊化是实际的具体实体(类/函数/...)，还是模板。如果不是，它们到底是什么?它们不是模板或专门化(遵循temp.spec p4提供的定义)
浏览 5提问于2019-05-29得票数 1
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
回答已采纳
下面是一个可编译的示例，我从几个头文件拼接在一起。代码没有意义，因为我分析了所有不相关的部分，但要点是我正在实现Scott的数据代理技术(提到)，尽管它更像是一个包装器，而不是临时代理。不过，这一切都不重要--我的问题似乎纯粹是关于编译器行为的差异。
#include <iostream>
#include <vector>
template<typename T>
class Proxy
{
public:
enum class State
{
NEVER_SET = 0,
SET,
UNS
浏览 1提问于2014-09-02得票数 3
回答已采纳
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
回答已采纳
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
回答已采纳
2回答
在用模板编写C++代码时，我会遇到三个问题。看来VS2013可以编译下面的代码。
这里的代码：
//template_test.h
#include <iostream>
using namespace std;
template<class T>
class mytest
{
public:
void method(T input);
void common();
};
template <>
class mytest<char>
{
public:
void method(char input);
void
浏览 2提问于2014-01-11得票数 1
回答已采纳
2回答
以下代码编译得很好：
#include <type_traits>
template <typename T> struct dependent_true : std::true_type { };
template <typename T> struct dependent_false : std::false_type { };
template <bool B = false>
class X { static_assert(dependent_false<X>::value); };
template <>
浏览 0提问于2018-09-02得票数 3
回答已采纳
示例：
namespace X{
inline namespace Y{
template<typename T>
struct A{
};
}
}
namespace X{
template<typename Z>
A(std::vector<Z>) -> A<Z>;
}
这将导致Clang 11中的编译错误，其中指出“必须在与模板X::Y::A__相同的范围内声明扣减指南”。
与模板专门化类似，演绎指南也应该在与类模板相同的语义范围内声明。那么为什么我可以专
浏览 3提问于2020-08-13得票数 5
1回答
C语言链接类型胡枝子&模板
、、、、
我理解模板不能出现在extern "C"块中，原因是实例化模板函数的名称不能使用未损坏的名称出现一次。
但是，在下面的代码中，函数的名称被损坏了(因此没有问题，因为每个实例化都有一个惟一的名称)，但是函数类型仍然带有C语言链接。我的问题是，以下的守则是否有良好的格式：
extern "C" using fn_type = void();
template<typename T>
fn_type foo;
int main()
{
fn_type* const p = foo<int>;
p();
}
编辑:很难通过编译
浏览 2提问于2013-10-18得票数 1
回答已采纳
2回答
我试图理解 (“类模板的模板参数演绎”论文，它已被当前的C++草案标准N4606所采用)。
我相信在最简单的情况下，我理解它是如何工作的，其中模板名标识单个模板：
template<class T>
struct S {
S(T);
S(const std::vector<T>&);
};
int main()
{
std::vector<int> v;
auto s = S(v);
}
S标识主模板，因此我们创建一个虚拟重载集，其中包括
template<class T> void Sctor(T);
浏览 3提问于2016-09-07得票数 4
3回答
如果我们考虑函数模板重载，C++中的标准行为是首先选择“最专门的”重载(从基本模板中选择)。下一步是查看所选的重载是否显式地专门化。如果是，则将选择匹配的显式专门化。。
您能否指出标准中定义第二步的位置(上一段中突出显示的部分)？
谢谢。
浏览 0提问于2018-09-11得票数 1
我不清楚编译器何时以及如何创建template函数。因此，我无法解释以下两个例子的行为。
例1.
struct C1 {
template <typename T>
void g(T t);
};
template<>
void C1::g(double x) {
cout << "Member templates. C1::g(double) " << x << endl;
}
上面
浏览 2提问于2015-09-16得票数 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
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
3回答
从不完整类继承的类模板
、、、
由于来自不完整类型()的继承，此代码无法编译：
template<typename>
class Incomplete;
class T : public Incomplete<T> {};
template<typename>
class Incomplete {};
int main()
{
[[maybe_unused]] T x;
}
我认为这个规则也适用于类模板。但是，这段代码编译精细()：
template<typename>
class Incomplete;
template<int d>
class T
浏览 2提问于2019-11-20得票数 3
回答已采纳
1回答
C++链接和模板的专门化
、、、、
我正在研究C++链接器在模板专门化方面的行为。在这些实验中，我使用了微软的VisualC++ 2010。我不知道其他工具链的行为是否相同(例如gcc)。
下面是第一个代码片段：
// bar.cpp
template <typename T> int foo() { return 1; }
int bar() { return foo<double>(); }
// main.cpp
template <typename T> int foo() { return 1; }
template <> int foo<double>
浏览 1提问于2011-08-25得票数 13
回答已采纳
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
回答已采纳
1回答
为什么下面的CTAD尝试无法编译？
template <typename T> struct C { C(T,T) {} };
template <> struct C<int> { C(int) {} };
C c(1); //error: template argument deduction failure
我原以为构造函数C(int)会被推导出来。
浏览 6提问于2022-01-15得票数 5
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回答
我想用另一种方式为指针、模板参数和其他参数类型定义一个成员函数。我尝试了以下代码：
#include <iostream>
template <class T, class W>
struct A
{
void foo();
};
template<class T, class W> void A<T*, W*>::foo(){ std::cout << "foo" << std::endl; }
int main(){ }
还不清楚为什么不起作用。我将指针模板参数按模板声明中指定的相同顺序
浏览 5提问于2015-03-08得票数 0
回答已采纳
我最近在专门化模板时遇到了一种情况，这让我感到不安：
foo.h：
template <class T>
void foo() {
std::cout << "This is the generic foo" << std::endl;
}
foo.cc：
#include "foo.h"
template <>
void foo<int>() {
std::cout << "This is foo<int>" << std::endl;
}
浏览 0提问于2013-02-28得票数 6
回答已采纳
我正在尝试创建一个概念来检查std::less是否有专门化。
看到上的std：：散列的概念示例，我创建了下面的代码：
#include <bit>
#include <complex>
#include <concepts>
#include <functional>
#include <iostream>
#include <type_traits>
template < typename DataType >
concept Lessable = requires(DataType value1, Dat
浏览 3提问于2021-03-07得票数 0
回答已采纳
我发现了一个我无法解释或找不到解释的有趣的观点。考虑以下模板定义(使用mingw g++ 4.6.2编译)：
template <typename T, typename S>
class Foo
{
public:
void f(){}
void g(){}
};
如果我们愿意，我们可以完全专门化任何单个成员函数：
template <>
void Foo<char,int>::f() {}
但部分专门化失败，并显示“无效使用不完整类型'class Foo<...>'”错误：
template <typen
浏览 3提问于2012-12-18得票数 9
回答已采纳
2回答
在使用template之前不实例化这个事实，例如，如果我有这个类模板：
template <typename T>
struct Pow{
T operator()(T const& x) const{ return x * x; }
};
void func(Pow<double>); // Pow<double> instantiated here?
void func(Pow<int>){} // Pow<int> instantiated here?
int main(){
Pow<int
浏览 6提问于2021-10-20得票数 7
回答已采纳
2回答
跨库的模板函数专用符号匹配
、、、、
到目前为止，我已经设置了一个函数模板getF是这样在标题中声明的
template <typename T> F* getF();
函数体未定义。然后，在共享库上，getF有一些专门化。
template<>
F* getF<int>()
{
static int r = 42;
static Finstance(r);
return &Finstance;
}
template<>
F* getF<float>()
{
static float r = 3.14159;
static Finstance
浏览 1提问于2014-06-22得票数 3
回答已采纳
1回答
我试图编写一段代码，尝试在模板中推导出两个参数包，并想知道为什么下面的代码不能工作
t.h (不工作)
#pragma once
#include <tuple>
namespace example
{
template<typename ... T>
struct Foo;
template<typename ... T1, typename ... T2>
struct Foo<std::tuple<T1...>, std::tuple<T2...>>
{
std::tuple<T1...>
浏览 1提问于2022-08-27得票数 1
回答已采纳
这是我的问题的简化形式(基于一个真正的库)：
// class template with static member variable:
template <typename T>
struct X
{
static std::vector<T> v_;
};
// definition of that static member variable:
template <typename T>
std::vector<T> X<T>::v_{};
// explicit instantiation of the class
浏览 5提问于2020-10-30得票数 1
回答已采纳
1回答
我有这些文件：
1.h :-
#include <iostream>
using namespace std;
template <typename A>
void f() {
cout<<"generic\n";
}
1.cpp :-
#include "1.h"
template <>
void f<int> () {
cout<<"for ints only\n";
}
main.cpp :-
#include "1.h"
int mai
浏览 0提问于2012-06-22得票数 7
回答已采纳
2回答
我有些课可以检查。实现此功能的代码在头文件中声明了一个函数模板，并专门处理不同的源文件：
// check.h
template <class T>
bool check(const T& object);
// class1.h
struct Class1 {int mass;};
// check_class1.cpp
#include "class1.h"
#include "check.h"
template <>
bool check(const Class1& object) {return object.ma
浏览 5提问于2019-11-06得票数 1
回答已采纳
1回答
C++可变模板演绎逻辑
、、、
我有简单的代码：
#include <iostream>
template<class... Types>
class A;
template<>
class A<> {
public:
explicit A() {
std::cout << "empty" << std::endl;
}
};
template<class Head, class... Tail>
class A<Head, Tail...> {
public:
exp
浏览 0提问于2019-11-20得票数 3
我使用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
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
腾讯会议
实时音视频活动推荐
腾讯云开发者
