C++ 是否可以用向量<；定义无序的_图；T>；作为价值？

我有一个向量模式，它们的getter如下：

vector<A>& getA() const { return a; }
vector<B>& getB() const { return b; }
vector<C>& getC() const { return c; }
...

vector&getA（）常量{return a；}
向量&getB（）常量{return b；}
向量&getC（）常量{return c；}
...

我对一些函数感兴趣，比如

vector&getByName（string s）const

，这样我就可以这样调用函数：

getByName（“A”）

，

getByName（“B”）

等等

我尝试过使用无序映射，但我没有找到任何合适的方法来生成这样的行：

unordered\u map

A、 B，C。。。都是完全不同的结构，所以多态性解决方案并不是我想要的

由于

vector

是一个大小固定的容器（如果我没有弄错的话，则为24个字节），我不明白为什么映射不能将这些字节存储在内存中的某个位置，而不管向量的类型如何

由于vector是一个大小固定的容器（如果我没有弄错的话，可以是24个字节），我不明白为什么映射不能将这些字节存储在内存中的某个位置，而不管vector的类型如何

因为C++是一种强类型的语言，而类型<代码>向量，<代码>向量和矢量< /代码>大小相同，这不重要，因为它们是不同的类型。p>

对

与

int32\t

的大小相同（在大多数实现中），但这并不意味着它们可以互换

我想你可以有一张

地图
由于vector是一个大小固定的容器（如果我没有弄错的话，可以是24个字节），我不明白为什么映射不能将这些字节存储在内存中的某个位置，而不管vector的类型如何

因为C++是一种强类型的语言，而类型<代码>向量，<代码>向量和矢量< /代码>大小相同，这不重要，因为它们是不同的类型。p>
对
与
int32\t
的大小相同（在大多数实现中），但这并不意味着它们可以互换

你可以（我想）有一张
地图你不能有
向量
，
向量
，。。在一张无序的地图中，因为它们有不同的类型。我认为下面的解决方案最符合您的需要：

#include <iostream>
#include <string>
#include <vector>
#include <unordered_map>

using namespace std;

template<typename T>
class my_unordered_map :
        public unordered_map<string, vector<T>> {
};

template<typename T>
vector<T>& get_by_name(const string& s, my_unordered_map<T>& mm) {
    return mm[s];
}

class A {
public:
    string name;

    A() = default;

    explicit A(const string& s) : name{s} {}
};

int main() {
    vector<A> vec_a1{A{"A1"}};

    my_unordered_map<A> mm;
    mm["A"] = vec_a1;

    vector<A>& vec_a2 = get_by_name("A", mm); //vec_a2 is the same as mm["A"]
    vec_a2.emplace_back("B");

    for (const auto& item : vec_a2) {
        cout << item.name << "\n";
    }

    return 0;
}

#包括
#包括
#包括
#包括
使用名称空间std；
模板
分类我的\u无序\u地图：
公共无序地图{
};
模板
向量&按名称获取（常量字符串&s，我的无序映射&mm）{
返回mm[s]；
}
甲级{
公众：
字符串名；
A（）=默认值；
显式A（常量字符串&s）：名称{s}{}
};
int main（）{
向量vec_a1{A{“a1}}；
我的_无序_地图mm；
mm[“A”]=vec_a1；
vector&vec_a2=get_by_name（“A”，mm）；//vec_a2与mm[“A”]
vec_a2.安置回（“B”）；
用于（常数自动和项目：vec_a2）{
不能将
向量
，
向量
，…放在一个
无序地图中，因为它们有不同的类型。我认为下面的解决方案最符合您的需要：

#include <iostream>
#include <string>
#include <vector>
#include <unordered_map>

using namespace std;

template<typename T>
class my_unordered_map :
        public unordered_map<string, vector<T>> {
};

template<typename T>
vector<T>& get_by_name(const string& s, my_unordered_map<T>& mm) {
    return mm[s];
}

class A {
public:
    string name;

    A() = default;

    explicit A(const string& s) : name{s} {}
};

int main() {
    vector<A> vec_a1{A{"A1"}};

    my_unordered_map<A> mm;
    mm["A"] = vec_a1;

    vector<A>& vec_a2 = get_by_name("A", mm); //vec_a2 is the same as mm["A"]
    vec_a2.emplace_back("B");

    for (const auto& item : vec_a2) {
        cout << item.name << "\n";
    }

    return 0;
}

#包括
#包括
#包括
#包括
使用名称空间std；
模板
分类我的\u无序\u地图：
公共无序地图{
};
模板
向量&按名称获取（常量字符串&s，我的无序映射&mm）{
返回mm[s]；
}
甲级{
公众：
字符串名；
A（）=默认值；
显式A（常量字符串&s）：名称{s}{}
};
int main（）{
向量vec_a1{A{“a1}}；
我的_无序_地图mm；
mm[“A”]=vec_a1；
vector&vec_a2=get_by_name（“A”，mm）；//vec_a2与mm[“A”]
vec_a2.安置回（“B”）；
用于（常数自动和项目：vec_a2）{
如果
A
B
和
C
都是不同的类型，那么这是不可能的，因为最大的问题是你不能声明
std:：vector
来保存不同的非多态类型你可以有一个模板函数
get\u vector（）
将返回
向量
但必须在编译时指定
T
，因此如果这是您的想法，它将不适用于运行时值。如果
a
B
和
C
都是不同的类型，那么这是不可能的，因为最大的问题是您不能声明
std:：vector
要保存不同的非多态类型，可以使用模板函数
get_vector（）
将返回一个
向量
但必须在编译时指定
T
，因此如果这是您的想法，它将不适用于运行时值。感谢您的解释。我不知道variant/any，在仔细阅读之后，这正是我在本期中所需要的。感谢您的解释关于。我不知道variant/any，在仔细阅读之后，这正是我在本期中所需要的。我对此表示感谢