std::variant使用模板化的类失败
std::variant是C++17引入的标准库模板类，用于表示可以存储多种不同类型的值的联合体。它提供了一种类型安全的方式来处理多态数据，类似于C++中的联合体和C中的共用体。
std::variant的主要特点包括：
- 类型安全：std::variant在编译时就会检查值的类型是否与定义的类型列表匹配，避免了运行时类型错误。
- 空间效率：std::variant只会占用足够存储最大类型的空间，避免了额外的内存开销。
- 高效访问：std::variant提供了访问当前存储的值的方法，可以直接访问当前类型的值，而无需进行类型转换。
然而，使用模板化的类时，可能会遇到一些失败的情况。这些失败可能包括编译错误、类型推导错误或者运行时错误。常见的失败原因包括：
- 类型不匹配：std::variant要求所有可能的类型都在定义时指定，如果使用了未定义的类型，编译时会报错。
- 类型转换问题：如果尝试将一个不匹配的类型赋值给std::variant对象，会导致编译错误或者运行时错误。
- 重复定义：如果在std::variant的类型列表中重复定义了相同的类型，会导致编译错误。
为了解决这些问题，可以采取以下措施：
- 检查类型列表：在使用std::variant之前，确保所有可能的类型都已经在类型列表中定义，并且没有重复定义。
- 使用类型转换：如果需要将一个类型转换为std::variant支持的类型，可以使用类型转换函数或者构造函数进行转换。
- 错误处理：在使用std::variant时，需要处理可能的错误情况，例如使用try-catch语句捕获运行时错误，或者使用静态断言来检查类型匹配。
腾讯云提供了多种云计算相关的产品，其中与std::variant相关的产品可能包括：
- 云函数（Serverless Cloud Function）：云函数是一种无服务器计算服务，可以在云端运行自定义的代码逻辑。可以使用云函数来处理std::variant类型的数据，并进行相应的业务逻辑处理。了解更多信息，请访问：云函数产品介绍
- 云数据库（TencentDB）：云数据库是腾讯云提供的高可用、可扩展的数据库服务。可以使用云数据库来存储std::variant类型的数据，并进行数据的读写操作。了解更多信息，请访问：云数据库产品介绍
- 人工智能服务（AI Services）：腾讯云提供了多种人工智能相关的服务，例如图像识别、语音识别、自然语言处理等。可以使用这些服务来处理std::variant类型的数据，并进行相应的人工智能处理。了解更多信息，请访问：人工智能服务产品介绍
总结：std::variant是C++17引入的标准库模板类，用于表示可以存储多种不同类型的值的联合体。它提供了类型安全、空间效率和高效访问的特点。在使用std::variant时，需要注意类型匹配、类型转换和错误处理等问题。腾讯云提供了多种云计算相关的产品，例如云函数、云数据库和人工智能服务，可以与std::variant结合使用，实现各种应用场景。
相关·内容
1回答
考虑一下在std::variant之上的递归变体的简化和非常具体的实现
#include <map>
#include <variant>
struct recursive_tag;
template <typename...>
struct RecursiveVariant;
template <>
struct RecursiveVariant<int, std::map<int, recursive_tag>>
: std::variant<int, std::map<int, Recurs
浏览 0提问于2018-05-29得票数 14
回答已采纳
1回答
当我调用模板函数时，我如何指定它的类型？
#include <string>
#include <utility>
#include <boost/variant.hpp>
template <typename O, typename E, template <typename, typename> class VariantType>
VariantType<O, E> f(O o)
{
return VariantType<O, E>{std::move(o)};
}
int main()
{
浏览 0提问于2018-01-30得票数 1
回答已采纳
如果some_class类被模板化，下面的代码将无法工作。所以我的猜测是，我必须把template的说明符放在前面，但我真的不知道在哪里？我尝试将它放在变量定义中的state::base和state::error类型前面，但这是行不通的。我该把它放哪儿?为什么？
#include <variant>
template <typename T>
class some_class
{
void do_something() {
struct state {
struct base{};
struct
浏览 8提问于2022-10-03得票数 2
回答已采纳
2回答
更改构造函数优先级
、、、
是否可以为所有派生类型定义一个构造函数和一个模板构造函数？我写了这个测试用例来说明我的问题：
#include <iostream>
class Variant;
class CustomVariant;
class Variant
{
public:
Variant(void)
{}
Variant(const Variant&)
{
std::cout << "ctor" << std::endl;
}
Variant(
浏览 3提问于2011-04-20得票数 4
回答已采纳
3回答
我有几个范围的boost::variant。在这种情况下，范围只是一个std::pair<It, It>，其中It是一个迭代器。我用它来存储满足某些属性的迭代器的范围。
因为我不知道迭代器的类型，所以我使用一个小的模板元编程来获得first_type的std::pair，因为我需要包含一个迭代器的第二个boost::variant (对应于该类型的一些活动元素)。
下面的代码被简化为帮助解决这个问题，但是考虑到我的RangeVariant中有一个未知的范围(这意味着我不能手动创建它，就像我可以为这个特殊情况所做的那样)。
#include <utility>
#incl
浏览 7提问于2016-03-18得票数 3
回答已采纳
1回答
我有一个类似这样的类：
template<class KeyType, class... Types>
class BasicCompound
{
public:
using mapped_type = std::variant
<
ValueWrapper<BasicCompound>
, ValueWrapper<Types>...
>;
using key_type = KeyType;
浏览 0提问于2018-11-22得票数 0
我正在试验boost::variant和打印标准类型，如以下所示，工作。
typedef boost::variant<int, std::string> myVariant;
myVariant my;
my = "Hello";
std::cout << my << endl;
但是当我引入定制类型
struct MyStructTag
{
uint32_t ver;
double kind;
std::string type;
};
typedef boost::variant<MyStructTag, st
浏览 6提问于2020-05-29得票数 2
回答已采纳
1回答
巴里给了我们
template <typename> struct tag { };
template <typename T, typename V>
struct get_index;
template <typename T, typename... Ts>
struct get_index<T, std::variant<Ts...>>
: std::integral_constant<size_t, std::variant<tag<Ts>...>(tag<T>()).
浏览 0提问于2018-12-06得票数 6
回答已采纳
在玩std::variant和std::visit时，出现了以下问题：
考虑以下代码：
using Variant = std::variant<int, float, double>;
auto lambda = [](auto&& variant) {
std::visit(
[](auto&& arg) {
using T = std::decay_t<decltype(arg)>;
if constexpr (std::is_same_v<T, int>) {
st
浏览 0提问于2019-05-08得票数 9
回答已采纳
1回答
是否可以像这个伪C++示例中的那样从整数序列中生成一个变量：
#include <utility>
#include <variant>
template <int MyInt>
struct MyStruct{};
using MyIntegerSequence = std::make_integer_sequence<int, 3>;
using MyVariant = std::variant<MyStruct<MyIntegerSequence>...>; // Does not compile
int m
浏览 1提问于2021-03-14得票数 2
回答已采纳
我有点惊讶，将变体的替代类型放入子命名空间似乎会破坏operator==
#include <variant>
#include <iostream>
namespace NS {
namespace structs {
struct A {};
struct B {};
} // namespace structs
using V = std::variant<structs::A, structs::B>;
bool operator==(const V& lhs, const V& rhs)
{
return
浏览 3提问于2020-12-08得票数 0
回答已采纳
我在研究C++实例化/声明顺序。这是我遇到的有趣之处：
该文件汇编如下：
#include <cstddef>
#include <variant>
#include <array>
template <size_t V>
struct container
{
// THIS COMPILES
struct array;
using val = std::variant<std::monostate, int, array>;
// THIS DOESNT
// using val = st
浏览 13提问于2022-07-29得票数 1
我想要创建一个字符串容器类型，检查它包含的字符串在构造时是否有效。在我看来，如果这个类的构造函数以std::string作为参数(只是为了确保不发生隐式类型转换)，应该更好。
但是当我在std::initializer_list中使用这个字符串容器(甚至在std::unordered_multimap中)时，如果我将构造函数定义为显式，就会得到一个错误。是否有一种方法可以将构造函数定义为显式并同时在std::multimap中使用？(即构造函数-我目前不知道的魔法类型的过载)
我准备了以下最起码的例子来说明这一点：
#include <utility>
#include <s
浏览 8提问于2022-08-26得票数 0
这段代码取自
using var_t = std::variant<int, long, double, std::string>;
template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
std::vector<var_t> vec = {10, 15l, 1.5, "hello"};
for (auto& v: vec) {
// 4. another type-matching visitor: a class with 3 o
浏览 2提问于2021-11-10得票数 2
1回答
以下代码没有编译(用/std:c++latest用MSVC 19.28进行测试，在godbolt.org上用-std=c++20测试Clang12.0)：
#include <variant>
struct some_thing;
using var = std::variant<some_thing>;
// There should be NO need to instantiate the template here, right?
void take(var* v) {}
int main() {
var* v = nullptr;
tak
浏览 3提问于2021-07-12得票数 5
回答已采纳
1回答
无序地图与地图
、、、、
有人知道为什么Dict类无效，但Dict2没有问题吗？
#include <string>
#include <unordered_map>
#include <map>
#include <variant>
class Dict
{
public:
Dict() {}
private:
std::unordered_map<std::string, std::variant<Dict, std::string>> data;
};
class Dict2
{
public:
Dict2()
浏览 1提问于2020-12-06得票数 0
回答已采纳
我确实理解std::variant在不完全类型下工作。但是，我不明白它是如何工作的，因为在我的理解中，std::variant必须需要它所包含的类型的最大大小。
那么，为什么这段代码不使用s1和s2进行编译。如何使它像std::variant一样工作
#include <variant>
#include <vector>
#include <type_traits>
#include <typeinfo>
#include <iostream>
struct Rect;
struct Circle;
using Shape =
浏览 0提问于2019-07-26得票数 2
回答已采纳
我想在不知道哪个是活动的情况下获得std::variant中的活动值。我想我可以写一个模板访问者，并使用std：：访问，但它不起作用。
#include <variant>
#include <string>
#include <iostream>
struct Visit_configuration {
template<typename Data_type>
Data_type operator()(Data_type& t) const
{
return t;
}
};
int m
浏览 1提问于2019-02-14得票数 7
回答已采纳
1回答
我正在使用std::variant和std::visit使用如下所示的：
#include <iostream>
#include <variant>
template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;
int main(void) {
std::variant<int, float>
浏览 3提问于2020-07-13得票数 3
回答已采纳
我有下面的代码，其中我定义了一个ostream <<-operator重载变量模板参数类型VariantContainer，它包含一个std::variant并使用来自VariantContainer for std::variant的可变模板参数
#include <iostream>
#include <variant>
template<typename... VARIANT_TYPES>
struct VariantContainer {
std::variant<VARIANT_TYPES...> var;
};
浏览 0提问于2020-12-29得票数 2
回答已采纳
我想编写自己的容器MyContainer。它实现了emplace方法来就地构造对象。
template<typename T>
MyContainer<T>::emplace(Args ... args)
{
// Some construction code ....
*_cursor = T(args...);
_cursor++;
return *item;
}
不过，我希望始终返回Allocator类型。不过，如果模板参数T的类型是std::variant，这就成了一个问题。我想做一个选择适合std::variant的重载
浏览 11提问于2019-07-21得票数 3
回答已采纳
我试图使用一个包装类和作为间接技术来定义和访问一个“递归”的。我的实现使用libstdc++，而不是libc++。
这就是我定义变体的方式：
struct my_variant_wrapper;
using my_variant_array = std::vector<my_variant_wrapper>; // <- indirection here
using my_variant = boost::variant<int, my_variant_array>;
struct my_variant_wrapper
{
my_variant _v
浏览 6提问于2016-10-13得票数 6
回答已采纳
1回答
以下代码无法编译： #include <functional>
#include <variant>
int main() {
using ret_void = std::function<void()>;
using ret_int = std::function<int()>;
std::variant<ret_void, ret_int> var;
var.emplace([](){ return 1; } );
} 编译器显示为template argument deduction/substituti
浏览 9提问于2019-12-19得票数 4
回答已采纳
2回答
我使用显式模板专门化来使用信息初始化std：：向量，但只对特定类型的std：：向量进行初始化，因此显式专门化。在构造函数中，如果我试图调用push_back或std::vector中的任何其他现有函数，编译就会失败。有什么问题，我该如何解决？
简化示例：
namespace std
{
template<>
class vector<int>
{
public:
vector(void)
{
int value = 5;
push_back(value);
}
};
}
编译器消息：
In constr
浏览 2提问于2013-12-27得票数 1
回答已采纳
1回答
当我使用boost::variant<int,std::string,bool>和它的访问者时，我遇到了一个意外的行为:字符串和布尔值是可比较的。我不知道为什么它是这样工作的，但我发现它很有趣。我唯一的想法是，带有布尔值的变量被解释为char？有人能给我解释一下吗？比较访问者：
#include <iostream>
#include <algorithm>
#include <vector>
#include <boost/variant.hpp>
#include <boost/function.hpp>
struc
浏览 4提问于2013-01-17得票数 2
回答已采纳
有时，您希望使用std::variant中的特定索引类型，并在没有实际对象的情况下使用该类型进行操作。一个示例用例是反序列化。您认为下面的方法如何？
/**
* @brief Used as placeholder to allow tag dispatching
*/
template<class T>
using empty = std::type_identity<T>;
/**
* @brief Find the index of the type that satisfies pred
浏览 0提问于2022-09-02得票数 1
回答已采纳
我面临着以下问题:我有一些boost::variant的访问者，它们都对特定类型执行相同的操作，在这里是foo，所以方法
void operator()(const foo& ast)
{
//allways the same
}
在每一个访问者身上都是一样的。因为我不想在所有访问者中编写这个冗余的方法，所以我尽量避免向所有访问者添加一个实现此方法的公共基类。问题是该方法递归地调用访问器本身，如下所示：
void operator(const foo& ast)
{
for(auto&& item : ast.members)
{
浏览 25提问于2016-09-23得票数 0
回答已采纳
1回答
我已经开始构建一个小的数据类型，在当前阶段，我在boost变体中只有一个递归类型。结果，当我试图实例化我的类型时，我会得到一个分段错误。如果我在递归类型之前放一个字符串，它就会工作，把它放在它不能使用的类型之后。我使用的是mingw，加上gcc 4.8.1 64位，然后是boost 1.54。
我是不是用错了助推变体？
#include <boost/variant.hpp>
#include <boost/variant/recursive_variant.hpp>
#include <string>
#include <iostream>
浏览 6提问于2013-10-24得票数 2
回答已采纳
我试图专门化一个函数模板，但是我得到了以下错误：
bar.cpp:12:39: error: template-id ‘getValue<>’ for ‘std::variant<int, double> Test::getValue(const string&)’ does not match any template declaration
12 | template <> std::variant<int, double> Test::getValue(const std:: string& name) {
浏览 4提问于2022-04-18得票数 0
我在以下几篇文章中看到了这个is_specialization实现：
//1 default
template<typename Test, template<typename...> class Ref>
struct is_specialization : std::false_type {};
//2 specialization
template<template<typename...> class Ref, typename... Args>
struct is_specializa
浏览 1提问于2021-02-19得票数 2
回答已采纳
描述了如何流独立的std::variant。但是，当std::variant存储在std::unordered_map中时，它似乎不起作用。
下面的
#include <iostream>
#include <string>
#include <variant>
#include <complex>
#include <unordered_map>
// https://stackoverflow.com/a/46893057/8414561
template<typename... Ts>
std::ostream&a
浏览 1提问于2018-10-17得票数 26
回答已采纳
1回答
不可复制，但可移动的容器
、、、、
我对这个程序有一个问题：
struct A {};
int main()
{
::std::vector< ::std::unique_ptr<A> > v;
::std::cout << ::std::is_copy_constructible<decltype(v)>{} << ::std::endl;
//decltype(v) w(v);
return 0;
}
这将输出以下内容：
1
但是，如果我取消对注释行的注释，程序将无法编译。你是否认为，这是标准中的一个错误，::std::is_copy_con
浏览 1提问于2014-02-19得票数 13
我想有一个程序，为我分析和管理命令行参数。正如您在main-function中看到的那样，通过使用Option<int>("number", { "-n", "--number" })之类的简单命令，您可以指定该选项的值应该具有的类型(如本例中的int )、每个选项的唯一标识符(如"number")，以及该选项可以使用的多个字符串。此外，许多选项应该包装在一个名为OptionSet的类中，这简化了对其选项的访问。
但是在我的实际代码中，我现在遇到了几个问题：
我希望在一个std::vector中存储具有不同模板参数
浏览 3提问于2016-01-27得票数 1
在下面的代码中，我希望将boost::hana::tuple转换为std::variant
namespace hana = boost::hana;
template <typename Tuple>
struct to_variant;
template <typename... Ts>
struct to_variant<std::tuple<Ts...>>
{
using type = std::variant<Ts...>;
};
auto my_tuple = hana::make_tuple(hana::t
浏览 10提问于2020-05-19得票数 0
回答已采纳
2回答
带模板游客的访客模式
、、、
这是对的跟进
我需要实现模板化的版本，如下所示，但是看起来accept函数必须是虚拟的，这是不可能的。你能帮帮我吗？
#include <variant>
#include <iostream>
class Visitable //I need this to be non-templated (no template for Visitable!!): Otherwise I could use CRTP to solve this issue.
{
public:
virtual ~Visitable() = default;
template&
浏览 11提问于2022-12-03得票数 2
回答已采纳
3回答
我希望有两个模板结构，用于将任何变体类型转换为std::strings；
当第一个编译时，第二个将不会在vector<Variant>::iterator statement上编译。编译器说：
error: expected ';' after expression
vector<Variant>::iterator i = data.begin();
知道我做错什么了吗？有没有更好的方法来做我在这里想做的事？
template <typename Variant>
struct to_string
{
private:
Va
浏览 4提问于2014-03-28得票数 1
回答已采纳
我有一个函数返回一个模板类。在此函数中，返回语句调用一个模板函数，该函数创建模板类的实例。在以下情况下，是否可以推断模板函数的模板参数？
#include <utility>
#include <variant>
template <class T, class U>
auto make(T&& t) -> std::variant<T, U> {
return std::variant<T, U>{ std::forward<T>(t) };
}
auto foo() -> std
浏览 3提问于2020-04-03得票数 0
回答已采纳
我正在尝试访问std：：变体类的方法。不幸的是，它抛出并出现以下错误：
class ’std::variant<A, int>’ has no member named ‘function’
代码：
class A {
private:
int number = 0;
public:
A() {};
void function(int i) {
number += i;
}
};
// ... main ...
std::variant<A,B> array[4][4];
array[0][0] = A(){};
ar
浏览 3提问于2020-06-26得票数 2
回答已采纳
1回答
我有下面的代码，它扩展了lambda的重载技巧，以也接受一个变体。然而，该变体并不是示例中的问题。
#include <memory>
#include <variant>
#include <functional>
template <class ...Fs>
struct overload : Fs... {
template <class ...Ts>
overload(Ts&& ...ts) : Fs{std::forward<Ts>(ts)}...
{}
us
浏览 0提问于2021-02-04得票数 0
回答已采纳
我的问题是这段代码到底是如何工作的：
std::variant<int, std::string> is;
constexpr int i = 0;
std::cout << std::get<i>(is);
现在，如果我编写以下代码，它将失败：
std::variant<int, std::string> is;
std::cout << std::get<is.index()>(is);
在文档中，我发现索引的返回类型是constexpr。有人能帮我一下吗？
更新
现在，通过使用std::string_view代替st
浏览 14提问于2019-11-01得票数 0
回答已采纳
我试图使用SFINAE来禁用基于一些非模板枚举参数的类的某些功能。
下面的代码不使用gcc进行编译，而是在使用msvc编译器时按预期的方式编译和工作。
#include <iostream>
#include <type_traits>
enum class B { VARIANT1, VARIANT2 };
template<B B_VAL>
struct A {
template<class = std::enable_if_t<B_VAL == B::VARIANT1>>
void func1() {
浏览 2提问于2020-07-28得票数 2
回答已采纳
我有一组模板类，我想把它们放在std::variant中。下面的工作非常糟糕(我在变体中有更多的类，有许多模板参数)。
template <typename T>
struct Type1
{ };
template <typename B, typename C>
struct Type2
{ };
template <typename A, typename B, typename C>
using Variant = std::variant<Type1<A>, Type2<B,C>>;
是否有可能以类似的方式“
浏览 0提问于2018-04-05得票数 3
2回答
我正在试验finate状态机和std::variant<..>
variant将保存所有可能的状态，这些状态将在State类中定义。
我希望std::monostate作为第一种状态变量类型，将其用作“不更改状态”值。因此定义为:第一种类型是std::monostate，第二种类型是fsm的初始状态。
因为std::variant被初始化为它的第一个元素，所以我想在构造函数中使用emplace<1>。
template <typename StateVariant>
class fsm
{
public:
StateVariant state;
浏览 13提问于2020-07-09得票数 2
3回答
我试图为具有编译时间常量的模板类构建专门化。
模板类如下所示：
template<class TNativeItem, class TComItem = void,
VARTYPE _vartype = _ATL_AutomationType<TComItem>::type>
class InOutComArray
{
private:
CComSafeArray<TComItem, _vartype> _safeArray;
// ...
public:
InOutComArray(
TNative
浏览 6提问于2014-08-18得票数 1
回答已采纳
2回答
静态模板成员函数的显式实例化始终无法使用消息error C2785: 'at_Intermediate CUtil::convert_variant(const VARIANT &)' and '<Unknown>' have different return types进行编译。
当我用非静态成员函数创建相应的类时，编译器喜欢我.
// utility class - static methods
struct CUtil {
template< typename at_Intermediate > static a
浏览 0提问于2009-01-08得票数 3
回答已采纳
2回答
我有两个不同的对象： struct TypeA {
std::size_t no;
std::string data;
std::string data2;
};
struct TypeB {
std::size_t no;
std::string data;
std::string data2;
std::string data3;
}; 它们通过std::variant存储在std::vector中 std::vector<std::variant< TypeA, TypeB>> ab; 现在，我想删除成员
浏览 26提问于2019-02-01得票数 5
回答已采纳
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
回答已采纳
代码：
#include <memory>
struct Data;
std::unique_ptr<Data> make_me();
int main()
{
std::unique_ptr<Data> m = make_me();
return 0;
}
当然哪一个失败了：
In file included from <source>:1:
In file included from /opt/compiler-explorer/gcc-7.1.0/lib/gcc/x86_64-linux-gnu/7.1.0/../../
浏览 2提问于2017-12-21得票数 15
回答已采纳
一些代码将有助于理解：
#include <variant>
#include <vector>
#include <string>
using MyType = std::variant<int, float, string>;
using ContainerOfMyType = std::vector<MyType>;
using MySuperType = std::variant<MyType, ContainerOfMyType>;
与其让MySuperType成为另一个std::variant的std::va
浏览 5提问于2022-03-29得票数 0
回答已采纳
1回答
快速提问：
是否有可能在运行时获得std::variant使用的底层类型？
我最初的猜测是这样使用decltype()：
std::variant<int, float> v;
v = 12;
std::vector<decltype(v)> vec;
但我的向量声明的类型是std::vector<std::variant<int, float>>，而不是std::vector<int>。
你知道我怎样才能做到这一点吗？
浏览 0提问于2018-02-07得票数 0
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
