参数包构造函数在类模板中隐藏用户定义的转换
是指在类模板中定义的构造函数可以隐藏用户自定义的转换函数。当使用类模板创建对象时，编译器会优先考虑使用类模板中定义的构造函数，而不是用户自定义的转换函数。
这种隐藏的优势在于可以避免意外的类型转换，确保对象的创建和初始化过程更加可控和准确。它可以防止不必要的类型转换，提高代码的可读性和可维护性。
参数包构造函数在类模板中隐藏用户定义的转换的应用场景包括但不限于以下几个方面：
- 类模板的构造函数可以根据不同的参数类型进行重载，提供更灵活的对象创建方式。
- 类模板的构造函数可以接受不定数量的参数，实现可变参数的对象初始化。
- 类模板的构造函数可以通过参数包的方式接受多个参数，简化代码编写和调用。
腾讯云相关产品和产品介绍链接地址：
- 腾讯云云服务器（CVM）：提供可扩展的云服务器实例，满足不同规模和需求的应用场景。
- 腾讯云云数据库 MySQL：提供高性能、可扩展的云数据库服务，支持数据备份、恢复和灾备等功能。
- 腾讯云人工智能：提供丰富的人工智能服务，包括图像识别、语音识别、自然语言处理等，帮助开发者构建智能化应用。
- 腾讯云物联网（IoT）：提供全面的物联网解决方案，包括设备接入、数据管理和应用开发等，支持各种物联网应用场景。
- 腾讯云移动开发：提供移动应用开发的云服务，包括移动推送、移动分析和移动测试等，帮助开发者构建高质量的移动应用。
- 腾讯云对象存储（COS）：提供安全可靠的云存储服务，支持海量数据存储和访问，适用于各种存储需求。
- 腾讯云区块链：提供可信赖的区块链服务，支持快速搭建和管理区块链网络，适用于金融、供应链等领域。
- 腾讯云元宇宙：提供虚拟现实和增强现实的云服务，支持开发和部署虚拟现实应用，创造沉浸式的交互体验。
相关·内容
1回答
我最近开始学习C++中的模板，我不确定是否需要在实现参数化构造函数时包括template <class T>。
template <class T>
class A
{ T num;
//default constructor (parameterized)
template <class T>//getting error
A(T value)
{ num=value;}
}
我得到一个错误阴影模板parm < class T>当我为这个template<class T>包
浏览 4提问于2015-05-31得票数 0
回答已采纳
考虑以下代码：
#include <utility>
template<typename T>
struct wrapper {
T value;
};
struct foo {
operator wrapper<int>() {
return{10};
}
};
int main() {
foo f;
wrapper w = f; // error
std::pair p = std::make_pair(1, 0); // ok
}
无法在上面标有标记的行编译：
main.cpp:
浏览 0提问于2017-06-18得票数 15
回答已采纳
我理解auto_ptr是如何在C++03中工作的。它是基于技巧。在编写这个auto_int p(auto_int(new int()));这样的代码时，这个技巧使用用户定义的转换将指针从一个对象窃取到另一个对象。然而，我在这方面有几个问题。
为什么编译器生成的复制-ctor不被调用？为什么用户定义的转换优先于编译器生成的复制-ctor？是否有编译器生成的复制-ctor开始？，如果没有，是什么语言规则抑制它？<code>g 212</code>
浏览 2提问于2012-05-25得票数 0
回答已采纳
在解析基类模板成员函数的重载过程中，我观察到了g++ (5.2.1-23)和clang (3.8.0)与-std=c++14之间的不同行为。
#include <iostream>
#include <type_traits>
struct Base
{
template <typename T>
auto a(T t) -> void {
std::cout<< "False\n";
}
};
template <bool Bool>
struct Derived : public Ba
浏览 3提问于2015-12-08得票数 14
回答已采纳
2回答
复杂物体的位置
、、、
我试图在一个对象中实现一个"emplace“特性。它的结构如下。我有一个模板对象，它将一个size_t对成一个模板类型。我希望能够在std库容器(例如，向量)中构建这一点。我不使用std::pair，因为我的类B将提供围绕数据的其他功能。
我需要如何修改代码，这样我才能像在主体中那样调用emplace？
#include <iostream>
#include <vector>
浏览 3提问于2017-12-18得票数 1
回答已采纳
2回答
嗨，以下两个是等价的：
template<class T>
class name {
public:
name() {/*...*/}
name(name const &o) {/*...*/} // WITHOUT TEMPLATE ARGUMENT
/*...*/
};
template<class T>
class name {
public:
name() {/*...*/}
name(name<T> const &o) {/*...*/} // WITH TEMPLATE ARGUMENT
浏览 4提问于2015-05-22得票数 2
回答已采纳
我找不到一个简短更好的标题。:(
假设我有一个简单的C++11模板类定义如下：
#include <utility>
template <typename T>
class A
{
public:
T v;
A(){};
template <typename U>
A(const A<U>& a); // copy ctor
A(A<T>&& a); // move ctor
};
template <typename T>
template &l
浏览 3提问于2015-11-06得票数 0
回答已采纳
1回答
类模板的模板参数演绎
、、、、
我正在阅读关于类模板的模板参数演绎的论文，这里是。这个特性在C++17标准中，有些东西使我感到困惑。
template <typename T>
class Something {
public:
// delete the copy and move constructors for simplicity
Something(const Something&) = delete;
Something(Something&&) = delete;
explicit Something(T&&) { ...
浏览 4提问于2017-06-03得票数 5
回答已采纳
给定以下模板结构：
template<typename T>
struct Foo {
Foo(T&&) {}
};
这是编译的，T被推断为int。
auto f = Foo(2);
但这不能编译：
int x = 2;
auto f = Foo(x);
/*
<source>:12:15: error: no viable constructor or deduction guide for deduction of template arguments of 'Foo'
auto f = Foo(x);
浏览 0提问于2020-02-29得票数 9
回答已采纳
tl；dr:如果复制构造函数前面有template<typename Something>，并且在构造函数签名中使用Something，则不会调用它。
概念证明()：
#include <cstdio>
template<typename T>
class Test {
private:
T value_;
public:
mutable bool has_copies;
Test(const T& value) : value_(value), has_copies(false) {}
template&l
浏览 4提问于2016-12-23得票数 3
回答已采纳
1回答
什么是构造函数继承？
、、、
在C++11中，继承构造函数是什么意思？如果它是我想的那样(基类构造函数被引入到派生类的作用域中)，那么它对我的代码有什么影响？这种特性的应用是什么？
浏览 4提问于2012-04-02得票数 68
回答已采纳
由于阅读了cplusplus标准中的一些引号，我对从派生类类型转换基类类型感到困惑。这种转换是否属于用户定义的转换？
引用一些让我对此感到困惑的话：
类对象的. can /1类型转换可以由构造函数和转换函数指定。这些转换称为用户定义的转换，用于隐式类型转换.class.conv.ctor/3类
非显式复制/移动构造函数(class.copy)是一个转换构造函数。
#include <iostream>
struct Base{
Base() = default;
Base(Base const&){}
};
struct Derived:Base{
};
浏览 2提问于2020-04-07得票数 2
回答已采纳
我正在构建一个自定义面板，在SL中绘制树，解决方案有一个SL应用项目和一个SL库项目(这是面板代码所在的地方)。节点之间的连接是库项目中的用户控件。我想要做的是在SL应用项目中拥有连接，然后将连接的类型传递给树库，这样用户就可以自定义树连接，而无需访问库项目。
我尝试了以下几点：
// pass the type of the connections in the constructor in the SL app project
var TC = new TreeContainer(typeof(TopToBottomConnectors.OffsetConnector),
浏览 3提问于2011-04-01得票数 2
回答已采纳
我正在制作CPP中的观察者，但我有一些问题。我只放置了两个文件，因为其他文件中出现了相同的错误。我像这样发送我的文件:包含原型声明的Event.hh和包含函数的Event.cpp。
这里是Event.hh：
#ifndef EVENT_HH
#define EVENT_HH
template <typename Object>
class Event {
public:
Event(Object* obj);
~Event();
Object* getInfo();
private:
Object* _obj;
};
#endif //EVEN
浏览 0提问于2018-10-30得票数 0
2回答
下面的代码在GCC下编译得很好，但是在clang中失败了，错误是：
没有用于初始化“Bar”的匹配构造函数
问题似乎在于clang认为Foo的模板构造函数被Bar的模板构造函数隐藏或覆盖。
这是clang中的错误，还是GCC的非标准化特征？
如何解决这个问题？我不能改变Foo，因为它是第三方。
#include <type_traits>
struct Foo {
Foo() = default;
template<typename T, std::enable_if_t<std::is_trivially_copyable_v<T&g
浏览 2提问于2019-11-05得票数 2
回答已采纳
1回答
谁能给我一个比2014-11-19的N4296更新的C++国际标准工作草案的参考吗？
或者有人能告诉我3.2.6.6条款(关于odr规则)中的例子是否正确？
我引用它：
// translation unit 1:
struct X {
X(int);
X(int, int);
};
X :: X(int = 0) { }
class D : public X { };
D d2; // X(int) called by D()
// translation unit 2:
struct X {
X(
浏览 0提问于2017-04-13得票数 0
2回答
我想定义一个模板类MyClass，其中模板参数必须是特定模板类的专门化。在本例中，我希望MyClass是一个模板类，它的第一个模板参数接受A的专门化，第二个模板参数接受B的专门化。然后，我可以实例化这个类如下：
MyClass<A<int, int>, B<double, int>>;
现在，您可能会说，“只需将A和B的参数作为MyClass的模板参数”。不幸的是，在我的情况下，A和B都是可变模板，因此MyClass的参数列表中不可能找到A模板参数的结尾和B模板参数的开头。
A和B的示例如下：
template <typename... Args>
浏览 6提问于2021-07-04得票数 0
4回答
对我最近的回答的一些评论表明，我对C++转换的理解是错误的。为了澄清这个问题，请考虑以下代码：
#include <string>
struct A {
A( const std::string & s ) {}
};
void func( const A & a ) {
}
int main() {
func( "one" ); // error
func( A("two") ); // ok
func( std::string("t
浏览 6提问于2009-05-15得票数 28
回答已采纳
用std=c++17作为唯一的编译器标志编译的代码片段.
..。用GCC 9.1成功编译。
..。使用Clang 8.0.0 (代码段下面的错误)发出编译器错误。
问题：，这是Clang编译器中的一个bug，还是GCC接受这段代码是错误的，还是在发挥其他作用？
#include <functional>
#include <tuple>
template <typename... Ts>
struct Foo
{
template <typename T>
using Int = int;
// Fun
浏览 0提问于2019-07-17得票数 13
回答已采纳
示例：
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
我希望有一个带有类依赖类型的参数的类，就像我经常为方法所做的那样。然而，令我惊讶的是，这并没有奏效：
scala> trait Compiler { trait Config }
defined trait Compiler
// works fine, as expected
scala> def f(c: Compiler)(conf: c.Config) = {}
f: (c: Compiler)(conf: c.Config)Unit
scala> class F(val c: Compiler)(val conf: c.Config)
<console&g
浏览 1提问于2015-09-24得票数 4
回答已采纳
1回答
您能告诉我如何显式调用模板构造函数(在初始化列表中)吗？例如：
struct T {
template<class> T();
};
struct U {
U() : t<void>() {} //does not work
T t;
};
谢谢
浏览 0提问于2010-05-07得票数 52
回答已采纳
2回答
因为我的一些代码需要在不同类型的矩阵之间进行隐式转换(例如，从Matrix<int>到Matrix<double>)，所以我定义了一个模板化的复制构造函数Matrix<T>::Matrix(Matrix<U> const&)，而不是标准的Matrix<T>::Matrix(Matrix<T> const&)
template <typename T> class Matrix {
public:
// ...
template <typename U> Matrix(
浏览 3提问于2009-08-08得票数 8
回答已采纳
1回答
我正在尝试实现一个哈希表，该哈希表可以以不同的方式调用，对于某些特定类型是否应该定义散列函数和相等操作符，如下所示：
struct FancyType{
//some data here
}
struct SomeHashStruct{
//operator() overload
}
struct SomeEqualStruct(){
//operator() overload
}
HashTable<string, FancyType, SomeHashStruct, SomeEqualStruct> table;
或者只定义键和值类型：
HashTable<stri
浏览 1提问于2019-12-01得票数 0
回答已采纳
我有一个小片段(用g++编译)，其中我定义了一个移动构造函数：
#include <iostream>
using namespace std;
class A {
public:
A() = delete;
A(int value) : value(value) {}
void operator=(const auto &other) = delete;
~A() { cout << "Destructor called..." << endl; }
A(const auto &other) {
浏览 5提问于2022-11-21得票数 3
回答已采纳
C++和Java在处理参数多态方面有类似之处:它们都会将类型参数推断为常规函数或方法，但都要求程序员在调用构造函数时显式地给出类型参数(尽管在Java 7中已经改变了这一点)。
这种行为背后的技术原因是什么？
编辑：我错误地认为这也适用于Scala。以下是Java的一个示例：
class Foo<T> {
Foo(T x) { }
}
<T> void foo(T x) { }
Foo<Integer> f = new Foo(3);
foo(3);
这两种方法都是合法的，但第一种是创建“原始类型”而不是Foo<Integer>，并
浏览 2提问于2013-12-20得票数 2
回答已采纳
using FuncDef = void(int a, int b);
template <typename R, typename... Args>
class WrongFunction {
public:
void F1(R(*Fn)(Args...)) {}//error: C2091 function returns function
};
template <typename T> class Function;
template <typename R, typename... Args>
class Function<R(A
浏览 4提问于2021-01-29得票数 3
回答已采纳
请考虑下面的基本程序。它有typedef int Number，其目的是允许未来的开发人员将其更改为当时最有意义的任何精度(甚至，甚至使用CGAL的数字类型之一)。
您可以看到，Point被描述为一对Number，LineSegment由两个Point描述。
我想实现两个目标：
如果用户试图用显式Number以外的任何东西实例化Point，则应该触发编译时警告。我认为explicit关键字就是这么做的。相反，正如您在实例化intIf中所看到的，我们静默地允许将float转换为用户希望用常量值对LineSegment进行初始化的float，只要这些值是Number.，就应该是可能的。
我的问题：
浏览 5提问于2019-12-13得票数 0
回答已采纳
2回答
我正在尝试理解一些C++语法：
template<class T>
class Foo
{
Foo();
template<class U>
Foo(const Foo<U>& other);
};
template<class T>
Foo<T>::Foo() { /*normal init*/ }
template<class T>
template<class U>
Foo<T>::Foo(const Foo<U>& other) { /*
浏览 5提问于2009-03-18得票数 1
回答已采纳
我的问题可以重复如下：
struct MyClass {
template<typename...Ts>
MyClass(Ts&&..., int) {};
};
int main() {
MyClass mc{1, 2 }; // error: cannot convert from 'initializer list' to 'MyClass'
}
我的密码怎么了？
浏览 1提问于2018-03-18得票数 0
回答已采纳
我一直试图找到一种方法来跳过模板参数列表末尾的模板参数，它位于一个派生类中，该派生类在基类中被指定为默认值。
我已经对这个话题做了一些研究，也是在这里。虽然类似的问题已经在这么多的答案上进行了讨论，但基本上表明它不起作用是与非常特殊的情况相关的，比如散列图案例。我还找到了"Potatoswatter“的答案，在我看来，这与跳过这样一个参数的可能性相矛盾。他在答复中声称，这一声明是有效的：
template< class A, class B = int, class C >
class X;
假设模板参数不可能被跳过(除非在参数列表的末尾)，那么这样的声明根本就没有意义。因
浏览 4提问于2015-09-05得票数 4
回答已采纳
请考虑以下程序及其中的评论：
template<class T>
struct S_ {
S_() = default;
// The template version does not forbid the compiler
// to generate the move constructor implicitly
template<class U> S_(const S_<U>&) = delete;
// If I make the "real" copy constructor
浏览 2提问于2014-07-18得票数 2
回答已采纳
我问如何用模板版本重载复制构造函数和赋值操作符，并考虑到围绕这个问题的混淆(因为它似乎是一个编译器错误)，我想我应该尝试只使用模板复制构造函数和模板赋值操作符来查看会发生什么。但是编译器完全忽略了它们。
struct BaseClass
{
public:
BaseClass() {}
template<typename T>
BaseClass(const T& a_other)
{
int i = 0; // for break point which is not hit
}
template<typename T>
浏览 3提问于2012-02-28得票数 6
回答已采纳
Clang 6、clang 7和gcc 7.1、7.2和7.3都同意以下是有效的C++17代码，但在C++14和C++11下是不明确的。MSVC 2015和2017也接受它。然而，即使在c++17模式下，gcc-8.1和8.2也拒绝它：
struct Foo
{
explicit Foo(int ptr);
};
template<class T>
struct Bar
{
operator T() const;
template<typename T2>
explicit operator T2() const;
};
Foo f
浏览 0提问于2018-11-01得票数 15
回答已采纳
2回答
我遇到了下面部分显示的这个模板化的智能指针类Cptr，我不理解其中的一个方法实现，并且希望得到一些输入。我的问题是“方法2”，标签如下。具体来说，如果Cptr是由T模板化的，那么可以使用什么调用语法来调用'Method 2‘，这至少在我看来是一个复制构造函数，但我认为复制构造函数没有模板化。
template <class T> class Cptr
{
public:
/* Constructors ... */
/* Getters ... */
T* ptr() const { return p_; }
浏览 3提问于2017-01-31得票数 0
回答已采纳
我本以为这会成功的
struct Parent
{
Parent ();
Parent (const Parent &);
};
struct Child : public Parent
{
using Parent::Parent;
};
Parent p;
Child c (p);
Child继承了Parent的所有构造函数，对吗？
包括Parent::Parent(const Parent &)
x.cpp:15:11: error: no matching function for call to ‘Child::Child(Parent
浏览 0提问于2019-09-13得票数 14
回答已采纳
1回答
经过几个小时的制作这个应用程序，我被困在谷歌登录，我已经问过问题，但仍然停留在。
所以我有logic.service.ts，它处理用户登录并将他们的数据存储在localStorage中
login(){
this.googlePlus.login({
'webClientId' : '927898787134-spvfdmvm9apq0e1fo2efvvura8vqpid8.apps.googleusercontent.com',
'offile' : true
}).then(res=>{
浏览 2提问于2019-12-08得票数 0
回答已采纳
1回答
我想我们可以在没有模板参数的情况下调用模板函数。为什么只有当我将模板参数指定为double时，此代码才能工作？
#include <iostream>
template <typename T>
T max(T x, T y)
{
return x > y ? x : y;
}
int main()
{
cout<<::max(3,4.7)<<"\n"; //Error
cout<<::max<int>(3,4.7)<<"\n"; //Er
浏览 0提问于2012-05-06得票数 0
回答已采纳
我试图设计一个工厂类，它允许我用任意数量的构造函数参数封装任何类的构造(从同一个基类“base”派生出来)。当前设计只支持一个或零构造函数参数：
class FactoryBase
{
public:
FactoryBase(std::string id) : id_(id) {}
virtual ~FactoryBase(){}
virtual Base* create() const = 0;
std::string getId() const { return id_; }
protected:
std::string id_;
};
templ
浏览 0提问于2014-02-16得票数 0
回答已采纳
1回答
我有像下面这样的代码，看起来有点混乱。我定义了一个模板类。它有一个用户定义的构造函数。当我通过"operator =“声明这个模板类的两个对象时，它的用户定义的构造器被调用了，这让我感到惊讶。此外，删除其复制构造函数后，在解析"operator =“时编译甚至无法通过。模板构造函数和非模板类有不同的规则吗？ #include "iostream"
using namespace std;
template
class MyPtr
{
private:
T p_;
public:
MyPtr(T P = NULL): p_(P)
{
浏览 46提问于2021-03-01得票数 2
回答已采纳
2回答
参加以下课程：
class mytype {
double num;
public:
mytype(int a) {
num = sqrt(a);
}
void print() {
cout << num;
}
}
假设有一种方法是以神话类型为基础的：
void foo(mytype a) {
a.print();
}
调用foo(4)是合法的c++ (或者是否有实现这一点的方法)，而foo(4)将(理论上)输出2？根
浏览 2提问于2010-04-20得票数 1
我有这个代码。在main中，我希望使用类型转换，但在使用debug时，我在这一行中理解为ob2=(Point2D<double>)ob1;
构造函数template <class T1> Point2D(Point2D<T1>& ob)被调用，而不考虑之前的explicit，即template <class T1> explicit Point2D(Point2D<T1>& ob)。为什么会发生这种情况？我希望调用operator Point2D<T1>()。
template <class T>
浏览 2提问于2011-12-11得票数 5
回答已采纳
2回答
如何调用模板类的模板ctor？
、、、、
template<typename T>
struct A
{
template<typename U>
A() {}
template<typename U>
static void f() {}
};
int main()
{
A<int>::f<int>(); // ok
auto a = A<int><double>(); // error C2062: type 'double' unexpected
}
这个问题在代码中是不言而喻的
浏览 5提问于2017-05-05得票数 4
回答已采纳
1回答
#include <cstddef>
template <class T, std::size_t rank_>
struct B { };
template <class T, std::size_t rank_>
struct A {
static constexpr auto rank = rank_;
operator B<T, rank>() noexcept;
};
template <class T, std::size_t rank>
A<T, rank>::operator B&
浏览 67提问于2019-06-09得票数 0
回答已采纳
1回答
给定以下代码
#include <iostream>
using namespace std;
template <typename Type>
struct Something {
Something() {
cout << "Something()" << endl;
}
template <typename SomethingType>
Something(SomethingType&&) {
cout <<
浏览 3提问于2017-04-09得票数 5
回答已采纳
3回答
#include <iostream>
class A
{
public:
A(bool b, int i)
: b_(b) , i_(i) {}
void print()
{
std::cout << b_ << " " << i_ << "\n";
}
private:
bool b_;
int i_;
};
class B
{
public:
B(
浏览 1提问于2020-02-13得票数 0
回答已采纳
假设我有一个库somelib.a，它由包管理器作为二进制文件分发。这个库使用了标头唯一的库anotherlib.hpp。
如果我现在将我的程序链接到somelib.a，并且也使用anotherlib.hpp，但是使用了不同的版本，那么如果somelib.a在其include头中使用了anotherlib.hpp的一部分，那么这可能会导致UB。
但是，如果somelib.a只在其cpp文件中引用/使用anotherlib.hpp (所以我不知道它是否使用它们)，会发生什么？我的应用程序和somelib.a之间的链接步骤将确保somelib.a和我的应用程序都使用它们自己的anotherlib.h
浏览 0提问于2019-03-13得票数 4
回答已采纳
2回答
下面的程序用GCC 5.2编写，但没有用clang 3.6编译：
constexpr bool flag();
template <bool b = flag()>
constexpr bool test()
{
return b;
}
int main()
{
}
我在clang中得到的错误消息是：
main.cpp:3:20: error: non-type template argument is not a constant expression
template <bool b = flag()>
^~~
浏览 4提问于2016-01-02得票数 19
回答已采纳
我有一个函数需要一个std::span参数。此函数通过传递一个std::array来调用。如果将std::span参数声明为模板参数Extent设置为std::dynamic_extent，则工作正常。但是，如果函数是在Extent上模板化的，编译器就无法从std::array参数中推断出这个值。
知道为什么编译器不能推断这个模板参数吗？
请参阅下面的代码段()。
评论后的更新
当我们在调用std::span时显式创建(不指定模板参数)对象时，一切正常，编译器能够从std::array中推断出span类型和Extent。在之后，对应的构造函数(5)没有标记为explicit。
那么，为什么编译
浏览 4提问于2022-02-04得票数 0
回答已采纳
2回答
为了保持简单和切题，我有一个类
class square
{
public:
square(int s); // parameterized constructor with default parameter = 0
square();
private:
int side; // holds the side of the square (whole number)
};
square::square() {
side = 0;
}
square::square(int s){
side = 0; // parameterized con
浏览 0提问于2017-12-06得票数 0
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
腾讯会议
实时音视频活动推荐
腾讯云开发者
