如何测试带有编译时已知长度的std::initializer_list的ctor？
在测试带有编译时已知长度的std::initializer_list的ctor时，可以采取以下步骤：
- 创建一个测试用例，包含一个std::initializer_list对象和一个期望的长度值。
- 调用被测试的构造函数，将std::initializer_list对象作为参数传入。
- 使用std::initializer_list的size()函数获取实际的长度值。
- 将实际的长度值与期望的长度值进行比较，确保它们相等。
- 如果长度值不相等，可以输出错误信息或者抛出异常，以便在测试中进行断言。
下面是一个示例代码：
#include <initializer_list>
#include <iostream>
class MyClass {
public:
MyClass(std::initializer_list<int> list) : data(list) {}
int getSize() const {
return data.size();
}
private:
std::initializer_list<int> data;
};
int main() {
std::initializer_list<int> list = {1, 2, 3};
int expectedSize = 3;
MyClass obj(list);
int actualSize = obj.getSize();
if (actualSize == expectedSize) {
std::cout << "Test passed!" << std::endl;
} else {
std::cout << "Test failed: expected size " << expectedSize << ", actual size " << actualSize << std::endl;
}
return 0;
}在这个示例中，我们创建了一个MyClass类，它接受一个std::initializer_list作为构造函数的参数。在main函数中，我们创建了一个包含三个元素的std::initializer_list，并将其传递给MyClass的构造函数。然后，我们使用getSize函数获取实际的长度值，并将其与期望的长度值进行比较，输出相应的测试结果。
腾讯云相关产品和产品介绍链接地址：
- 腾讯云函数计算（云原生、服务器运维）：https://cloud.tencent.com/product/scf
- 腾讯云数据库（数据库）：https://cloud.tencent.com/product/cdb
- 腾讯云CDN（网络通信）：https://cloud.tencent.com/product/cdn
- 腾讯云安全产品（网络安全）：https://cloud.tencent.com/solution/security
- 腾讯云音视频处理（音视频、多媒体处理）：https://cloud.tencent.com/product/mps
- 腾讯云人工智能（人工智能）：https://cloud.tencent.com/product/ai
- 腾讯云物联网（物联网）：https://cloud.tencent.com/product/iotexplorer
- 腾讯云移动开发（移动开发）：https://cloud.tencent.com/product/mobapp
- 腾讯云对象存储（存储）：https://cloud.tencent.com/product/cos
- 腾讯云区块链（区块链）：https://cloud.tencent.com/product/baas
- 腾讯云虚拟专用云（元宇宙）：https://cloud.tencent.com/product/vpc
相关·内容
我可以看到std::string只有一个带有initializer_list：string (initializer_list<char> il);的CTOR，所以初始化程序列表应该与chars一起工作，对吗？为什么std::string{"some_str"}工作，它得到了const char*，对吗？
浏览 4提问于2015-10-23得票数 0
回答已采纳
1回答
我有一个带有模板参数T的类template Templ，Templ类有一个T类型的数据成员，称为obj。我编写了一个可变构造函数模板，它将参数转发给obj的构造函数：
template <class T>
class Templ
{
public:
template <class... Args> explicit Templ (Args&&... args)
: obj (std::forward<Args>(args)...)
{
}
private:
T obj;
};
现在我意识到类型
浏览 0提问于2013-02-11得票数 5
回答已采纳
2回答
考虑以下最小的示例：
#include <iostream>
struct X {
X() { std::cout << "Default-ctor" << std::endl; }
X(std::initializer_list<int> l) {
std::cout << "Ilist-ctor: " << l.size() << std::endl;
}
};
int main() {
X a{};
X b({}); // r
浏览 1提问于2020-12-15得票数 14
回答已采纳
以下是问题所在：
int main()
{
constexpr std::initializer_list<int> my_ints {1, 2, 3};
}
我正在尝试用g++ (x8664-posix-seh-rev0，版本8.1.0)编译上面的代码。但VS Code会引发以下警告：
“表达式必须具有常量值--指向具有有限生存期的临时引用或指针”
当我删除constexpr说明符时，即当我将代码修改为
int main()
{
std::initializer_list<int> my_ints {1, 2, 3};
}
错误消失了，所以声明一个
浏览 0提问于2020-09-27得票数 1
1回答
是否有任何方法来进行初始化列表折叠，而不是使用参数包？我的问题是，我有一个重载的构造函数，我想根据是否使用{}调用不同的构造函数。对于初始化程序列表来说，这似乎很好，当我使用{}时，它可以隐藏我的另一个参数构造函数，而不是我使用()构造它的时候，但是如果我使用一个参数包而不隐藏另一个参数构造函数，它就会失败。
此外，我还看到人们在他们的折叠表达式中附加了一个空白，当我提到cp偏好时，我无法理解这一点，我的程序似乎也没有什么不同。
编辑:根据要求，举一个例子来说明这个问题：
#include <iostream>
#define USE_PARAMETER_PACK false
t
浏览 0提问于2019-04-07得票数 0
回答已采纳
对于下面的示例，为什么没有触发向量移动操作？我如何知道什么时候应该显式使用移动操作符？
#include <iostream>
#include <vector>
using namespace std;
class Test {
public:
Test() {
std::cout << " default " << std::endl;
}
Test(const Test& o) {
std::cout <<
浏览 2提问于2022-05-17得票数 4
回答已采纳
我有一个函数func <T> (...)，它必须分成两个分支；
第一分支:当类型T有T(std::initializer_list<U>)构造函数时。
第二分支:当类型T没有T(std::initializer_list<U>)构造函数时。
我目前的实现如下：
template<typename T, typename U>
using has_init_list_ctor = std::enable_if_t<std::is_constructible_v<
T,
std::initializer_l
浏览 0提问于2019-08-11得票数 2
回答已采纳
我有一个嵌套的initializer_list ctor，用于创建2D矩阵。效果很好。但是，我决定使用一个初始化程序列表添加一个简化的行向量矩阵(n行，1 col)。这样我就可以创建这样的行矩阵：Matrix2D<int> x{1,2,3}，而不必执行以下操作：Matrix2D<int> x{{1},{2},{3}}。当然，这需要一个单独的角色。
一切正常，包括与MSVC一起工作。但是，如果用gcc和clang检查一下，我就会发现一些模糊的因素。在我看来，清单是嵌套的，MSVC的操作与预期完全一致。
下面是代码：
// Comment out next line for
浏览 6提问于2022-08-29得票数 3
回答已采纳
2回答
我有一段代码：
#include <iostream>
#include <vector>
using namespace std;
class Foo{
public:
Foo() noexcept {cout << "ctor" << endl;}
Foo(const Foo&) noexcept {cout << "copy ctor" << endl;}
Foo(Foo&&) noexcept {cout << "
浏览 8提问于2014-07-17得票数 2
回答已采纳
2回答
struct X
{
X() { std::cout << "default ctor" << std::endl; }
};
int main()
{
X({});
}
这个打印出来
default ctor
这是有意义的，因为空大括号值-初始化对象(我认为)。然而，
struct X
{
X() { std::cout << "default ctor" << std::endl; }
X(std::initializer_list<int>) { std::co
浏览 0提问于2018-02-05得票数 11
回答已采纳
考虑使用模板构造函数从std容器继承的类，模板构造函数调用容器的底层构造函数。此模板构造函数适用于简单的复制和移动构造函数，但不适用于initializer_list ctor。
template<typename container_T>
class test : public container_T {
public:
using container_type = container_T;
test() {}
// templated constructor
template<typename T>
test(T t)
: cont
浏览 3提问于2013-10-20得票数 5
回答已采纳
考虑以下方案：
#include <stdexcept>
#include <stdio.h>
#include <memory>
#include <list>
class Foo {
public:
Foo(){
if (s_ct==0) {throw std::bad_alloc();}
--s_ct;
fprintf(stderr, "ctor %p\n", this);
}
~Foo(){
fprintf(stderr, "d
浏览 1提问于2016-08-17得票数 22
回答已采纳
考虑到下面的代码片段..。
void boo(std::initializer_list<unsigned> l)
{
}
template <class T>
void foo(std::initializer_list<T> l)
{
//Even though T is convertable, initializer list is not...:-(
boo(move(l));
}
int main()
{
foo({1u,2u,3u}); //Compiles fine as expected
foo({1,2
浏览 4提问于2015-11-30得票数 2
回答已采纳
1回答
我对C++11列表的初始化很好奇。我定义了一个类：
class base{
base() { cout << "default ctor" << endl;}
base(std::initiazer_list<base> il) { cout << "list initialization << endl;}
base(const base &rhs) { cout << "copy ctor" << endl;}
}
在main函数中，我初始化了两个
浏览 2提问于2016-12-06得票数 1
2回答
为了尝试将数组传递给函数，并防止每次写入"std::unique_ptr“，并使内联构造成为可能，我引入了typedef (ItemList)来别名该数组。
#include <iostream>
#include <memory>
class Base {
public:
Base()
{
std::cout << "Base ctor" << std::endl;
};
virtual ~Base()
{
std::cout <<
浏览 4提问于2016-11-05得票数 0
回答已采纳
#include <iostream>
struct X {
X(std::initializer_list<int> list) { std::cout << "list" << std::endl; }
X(float f) { std::cout << "float" << std::endl; }
};
int main() {
int x { 1.0f };
X a(1); // float (implicit conversion)
浏览 9提问于2013-06-05得票数 20
回答已采纳
为什么下面的代码提供不同的输出？
std::vector<int> v{12};
std::cout << v.size() << std::endl;
std::vector<int> v(12);
std::cout << v.size() << std::endl;
如果我列出-初始化一个对象，该对象具有接受initializer_list作为参数的ctor？
如何通过列表初始化调用std::vector::vector(size_t)？
浏览 5提问于2022-04-04得票数 1
回答已采纳
我试图用reshape (11/14)实现fortran的C++函数，并设计了一个函数。此函数接受两个std::initializer_list。第一个initializer_list给出了初始化D-dimensional数组的初始值。第二个initializer_list给出数组每个维度的大小。我写了一个这样的草稿
template<int D, typename T>
auto forreshape(const std::initializer_list<T> & values, const std::initializer_list<int>
浏览 3提问于2016-12-24得票数 1
回答已采纳
下面的类型有三个构造函数。请注意，其中之一接受相同类型元素的初始化程序列表。
struct Foo {
Foo() {
std::cout << "default ctor" << std::endl;
}
Foo(const Foo&) {
std::cout << "copy ctor" << std::endl;
}
Foo(std::initializer_list<Foo>) {
std::cout
浏览 0提问于2017-08-19得票数 1
回答已采纳
我需要在C++中创建一个交互式会话，用户可以在其中测试我创建的类。这包括使用不同的构造函数创建该类的对象。其中之一是使用initializer_list的集合构造函数。
在我的代码中，我可以运行：
MyClass example = {1, 2, 3, 4};
现在，我需要找到在交互式会话中使用它的方法。不知何故，我需要用用户提供的输入填充{}。用户可以在这个列表中传递多达100个讨论，所以我可能需要某种循环解决方案来解决我的问题。类似的事情(对不起C++/Python伪代码混合物)：
MyClass example = {a for a in user_input};
你知道我能用什么来解决
浏览 1提问于2020-03-29得票数 0
回答已采纳
1回答
在下面的代码中，std::string_view参数比const char*参数更好吗？
void func( const std::string_view str )
{
std::istringstream iss( str.data( ) ); // str is passed to the ctor of istringstream
std::size_t pos { };
int num { std::stoi( str.data( ), &pos, 10 ) }; // and here it's passed to std::stoi
浏览 1提问于2021-11-29得票数 0
回答已采纳
4回答
#include <iostream>
#include <vector>
#include <string>
void function1(const char** keywords) { // C like
for (const char** keyword = keywords; *keyword; ++keyword) {
std::cout << *keyword << std::endl;
}
}
void function2(const std::vector<std::str
浏览 7提问于2020-02-19得票数 0
回答已采纳
我有一个使用std::discrete_distribution的类，它可以使用std::initializer_list或几个迭代器。我的类在某种程度上包装了discrete_distribution，所以我真的很想模仿std::initializer_list的能力，然后再传下去。
这很简单。
然而，std::initializer_list总是通过一些未知的值来构造的。所以，如果它只是一个std::discrete_distribution，我就会用某个容器的迭代器构造它。但是，要想通过我的类提供这些信息，我需要对Iterator类型的类进行临时化。
我不想模板我的类，因为它只是偶尔使用
浏览 4提问于2015-03-28得票数 1
回答已采纳
在std::optional::emplace 中，存在接受std::initializer_list的重载。
template< class U, class... Args >
T& emplace( std::initializer_list<U> ilist, Args&&... args );
但条件是
std::is_constructible<T，std::initializer_list&，Args&&...>::value是真的
我认为它可能用于嵌入POD类型，但显然它不是这样工作的(
浏览 3提问于2021-06-09得票数 4
回答已采纳
我有一个wrapper类来包装std::vector<int>数据成员。我希望wrapper的构造函数将它的参数转发给vector<int>的ctor。我尝试使用一个可变的模板构造函数来实现这一点。由于std::vector<int> v{1, 2, 3}是由它的std::initializer_list ctor构造的，所以当我这样做时，希望wrapper激活vector的initializer_list ctor。
wrapper mywrap{1, 2, 3}。
但我没有得到想要的结果：
#include <iostream>
#inclu
浏览 0提问于2013-12-18得票数 2
回答已采纳
当我试图理解现代C++中不同类型的初始化时，我遇到了带有初始化列表的std::vector<T>初始化。要允许使用初始化器进行初始化，列表数据结构(如std::vector<T> )应该有一个构造函数，该构造函数接受初始化程序作为参数。我观察到，std::vector<T>通过复制接受初始化程序列表，而不是作为引用，当我们有大量的元素时，通过复制接受可能是非常昂贵的。为什么是这样的，是否有什么特殊的原因，为什么初始化列表将其作为副本而不是引用？
来自
vector( std::initializer_list<T> init, … ); (9)
浏览 4提问于2020-03-10得票数 5
回答已采纳
为什么要编译这段代码？
#include <string>
#include <variant>
#include <map>
void foo(std::map<int, std::variant<int, std::string>> map)
{}
int main()
{
foo({{1,"1"}, {2, 2}});
}
我们有应该用来初始化std::map的{{1,"1"}, {2, 2}}对象。这可能与接受std::initializer_list & list-init
浏览 5提问于2021-01-21得票数 1
每个人都是从std::initializer_list创建std::initializer_list的，但反过来又如何呢？
例如：如果使用std::initializer_list作为参数：
void someThing(std::initializer_list<int> items)
{
...
}
有时，您将项放在vector<T>中而不是文字列表中：
std::vector<int> v;
// populate v with values
someThing(v); // boom! No viable conversion etc.
更普遍的问题
浏览 16提问于2013-09-19得票数 79
回答已采纳
1回答
在最近的SO 中，我无法理解发生了什么，
struct VariableDepthList : std::variant<std::vector<VariableDepthList>, int> {
private:
using base = std::variant<std::vector<VariableDepthList>, int>;
public:
using base::base;
VariableDepthList(std::initializer_list<VariableDepthList>
浏览 7提问于2021-12-22得票数 0
回答已采纳
我不明白为什么这样做很好：
std::array<double, 2> someArray = {0,1};
std::shared_ptr<MyClass> myobj = std::make_shared<MyClass>(someArray);
但这是行不通的：
std::shared_ptr<MyClass> myobj = std::make_shared<MyClass>({0,1});
编译器说：
too many arguments to function ‘std::shared_ptr< _Tp> st
浏览 4提问于2019-09-27得票数 3
回答已采纳
我一直认为std::initializer_list是一个轻量级代理对象，它只从列表项中获取const引用，而不是复制它们。但后来我发现副本实际上是在这个例子中执行的：
struct Test {
Test() {
std::cout << this << " default ctor" << std::endl;
}
Test(const Test&) {
std::cout << this << " copy ctor" <&l
浏览 0提问于2019-01-24得票数 4
回答已采纳
在C++11中，我们可以在迭代容器时使用一个简单得多的"for“循环，如下所示：
for (auto i : {1, 2, 3, 4})
...;
但是，我不知道这些代码的效率。具体地说：
{1，2，3，4}的类型是什么？它是一个原始数组，或者转换为其他容器，如std::vector?Will编译器展开循环？。
Update:假设我们使用的是-O2，而循环中的代码只是几个操作。作为我的例子，我想让四个方向从左到右，并调用一个带有方向参数的函数。我只关心这个程序能不能有最好的表现。
非常感谢!
浏览 2提问于2020-08-31得票数 6
回答已采纳
1回答
我有一些代码可以有效地简化为
#include <vector>
class A {
std::vector<int> m_sizes;
public:
A(std::initializer_list<int> const& sizes) : m_sizes(sizes) {}
};
class B {
A m_a;
public:
B(int size_front, int size_back, std::initializer_list<int> const& sizes) : m_a({ s
浏览 1提问于2017-02-07得票数 2
回答已采纳
我从了解到，std::initializer_list不需要分配堆内存。这对我来说非常奇怪，因为您可以在不指定大小的情况下接受std::initializer_list对象，而对于数组，总是需要指定大小。虽然初始化器在内部列出的列表与数组几乎相同(如post所建议的)，但情况却是如此。
我很难理解的是，使用C++作为静态类型化语言，每个对象的内存布局(和大小)必须在编译时固定。因此，每个std::array都是另一种类型，我们只是从一个公共模板中派生出这些类型。但是对于std::initializer_list，这个规则显然不适用，因为内存布局(虽然可以从传递给其构造函数的参数派生)不需要考虑
浏览 11提问于2022-05-25得票数 18
回答已采纳
在我的项目中，需要在运行时追加初始化程序列表。
我已经找到了在运行时让initializer_list std::initializer_list<std::pair<std::string、std::string>>在我的项目中使用的方法，但如果用户传递多个no，则无法找到追加此列表的方法。成双成对。
该部分的虚拟代码实现如下：
#include <iostream>
#include <string.h>
#include <initializer_list>
#define __FILENAME__ strrchr(__FI
浏览 4提问于2022-09-11得票数 0
回答已采纳
1回答
运行时的C++ N嵌套向量
、、、、
在C++ (有或没有boost)中，我如何创建一个N维向量，其中N是在运行时确定的？
大致是这样的：
PROCEDURE buildNVectors(int n)
std::vector < n dimensional std::vector > *structure = new std::vector< n dimensional std::vector >()
END
如果传递1，将分配一个向量。如果传递2，将分配一个2d嵌套矩阵。如果传递3，则分配3d立方体。等。
浏览 1提问于2017-04-12得票数 4
我不能在函数中使用constexpr值，而不是函数的外部。
我可以在定义auto ar1 = std::array<int, il.size()>();的作用域中使用il。
但是我不能在{ return std::array<T, il.size()>();}中使用constexpr-function il_to_array()
为什么我不能在函数中使用constexpr值，但是我可以在这个值的块范围内这样做？
#include <iostream>
#include <initializer_list>
#include &l
浏览 0提问于2016-08-13得票数 9
回答已采纳
在模板元编程中，有一个技巧：
template <typename T>
struct my_struct {};
template <typename... T1, typename... Ts>
struct my_struct <std::tuple<T1, Ts...>>
{
// Tuple is "unpacked"
// I can freely work on 'T1' & 'Ts' types (through recursion) in this sco
浏览 1提问于2019-08-11得票数 3
使用std::string_view，range::for_each产生精确的程序集，const char[N]和const char *都传递给std::string_view ctor。
换句话说，这个代码
auto str = "the quick brown fox is jumping on a lazy dog\nthe quick brown fox is jumping on a lazy dog\n";
ranges::for_each(std::string_view{str}, std::putchar);
和
auto& str = "t
浏览 0提问于2018-03-06得票数 5
比方说，我在一个名为stA的类中封装了一个一维数组。
class stA
{
public:
template<typename ... T>
stA(T ... t):
data_{t...}
{}
private:
int data_[2];
};
通过利用各种模板，我可以成功地实现这个想法。
stA a = {1, 2};
但是，当我试图把这个技巧引入名为stB的二维类时，
class stB
{
public:
template<typename ... T>
stB(T ... t):
浏览 0提问于2019-07-29得票数 4
回答已采纳
第一部分:
std::initializer_list是C++11的一个非常有用的特性，所以我想知道它如何在标准库中实现。根据我读取的，编译器创建一个类型为T的数组，并给出指向initializer_list<T>的指针。
它还指出，复制一个initializer_list将创建一个引用相同数据的新对象:为什么会这样？我本可以猜到这一点：
复制新initializer_list的数据
将数据的所有权移动到新的initializer_list
第二部分:
来自std::vector构造函数的许多在线引用中的一个：
vector (initializer_list<
浏览 5提问于2013-06-03得票数 6
回答已采纳
3回答
初始化程序列表的赋值
、、、、
下面的代码是我问题的最小例子。我创建了一个包含固定大小数组的简单模板类，并重载赋值操作符以接受定义方法size()和begin() (例如，initializer_lists)的任何类。我不明白为什么g++不能解决我打给这个接线员的电话(我用gcc 4.6)：
***.cpp: In function ‘int main()’:
***.cpp:46:22: error: no match for ‘operator=’ in ‘a = {42, -1.0e+0, 3.14158999999999988261834005243144929409027099609375e+0}’
***.cpp
浏览 0提问于2014-04-20得票数 2
回答已采纳
在这里，我有一个构造函数，它将接受std::vector<>或std::initializer_list，但它不接受初始化器列表。被注释掉的ctor将接受初始值设定项列表，但不接受std::vector<>或std::initializer_list。
class C
{
std::vector<int> values;
public:
template <class Container> explicit C(const Container& container)
{
values = std:
浏览 0提问于2018-04-02得票数 2
考虑以下代码片段：
#include <iostream>
#include <initializer_list>
struct C
{
C(std::initializer_list<int>) { std::cout << "list\n"; }
C(std::initializer_list<int>, std::initializer_list<int>) { std::cout << "twice-list\n"; }
};
int main()
{
浏览 3提问于2015-07-03得票数 6
回答已采纳
这是这个问题的后续：。
自C++14以来，std::initializer_list类的所有方法都标记为constexpr。通过执行constexpr std::initializer_list<int> list = {1, 2, 3};初始化实例似乎很自然，但是Clang3.5抱怨list没有被常量表达式初始化。，任何要求std::initializer_list为文字类型的要求似乎已经从规范中消失了。
如果我们甚至不能像这样初始化一个类，那么将一个类完全定义为警察又有什么意义呢？这是标准中的疏忽，将来会被修正吗？
浏览 1提问于2014-12-16得票数 65
回答已采纳
我可以使用std::initializer_list对象而不是大括号括起来的初始化器来初始化数组吗？
众所周知，我们可以这样做：
unsigned char b[5]{"abc"};
// equivalent to unsigned char b[5] = {'a', 'b', 'c', '\0', '\0'};
int ar[] = {1,2,3};
std::array<int, 3> std_ar2{ {1,2,3} }; // std::array is an aggr
浏览 3提问于2016-08-13得票数 12
回答已采纳
我使用printf编写了一个std::initializer_list函数
template<typename T, typename... Ts>
auto printf(T t, Ts... args) {
std::cout << t << std::endl;
return std::initializer_list<T>{([&] {
std::cout << args << std::endl;
}(), t)...};
}
int main() {
p
浏览 0提问于2019-07-11得票数 2
回答已采纳
2回答
在c++中有可能创建一个可变长度的initializer_list吗？
举个例子：
std::list<string> mylist { somemagic (listSize, "default") };
或者：
QList<MyClass> anotherList { somemagic (listSize, {MyClassInitializerHere} ) };
浏览 1提问于2014-07-10得票数 0
std::vector的初始化程序列表构造函数具有以下形式
vector( std::initializer_list<T> init, const Allocator& alloc = Allocator() );
是什么使得像std::vector<string> vec{ “foo”, “bar” };这样的初始化成为可能？为什么构造函数接受std::initializer_list<const char*>，即使std::vectors的T是std::string？从std::initializer_list<const char*&g
浏览 12提问于2022-09-05得票数 3
回答已采纳
1回答
我有一个widget班。
我有一个抽象类base，带有派生词derived_a、derived_b等。
我希望widget能够保存从base派生出来的任意数量的对象，以便以后能够多形性地使用它们。
我的第一次尝试是这样的：
#include <vector>
#include <ostream>
#include <iostream>
#include <memory>
class widget {
public:
explicit widget(std::vector<std::unique_ptr<base>>
浏览 1提问于2016-10-28得票数 5
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
即时通信 IM活动推荐
腾讯云开发者
