如何定义从标准类型到用户定义类型的转换？ 我正在研究一个C++文件，它可以执行赫夫曼编码，当从字符串类型和int类型的映射变成类型节点< /COD>的队列时，遇到了一个问题，并且想知道是否有一种方法可以从一对字符串和INT定义一个显式转换，转换为节点< /C> > // this->char_freqs is of type map<std::string, int> std::vector<std::pair<std::string, int> > my_vector(this->char_freqs.begin(), this->char_freqs.end()); std::vector<Huffman::Node*> real_vector; for (unsigned int i = 0; i < my_vector.size(); ++i) { real_vector.push_back(new Huffman::Node(my_vector[i].first, my_vector[i].second)); } std::priority_queue<Huffman::Node*, std::vector<Huffman::Node*>, Huffman::comp> PQ(real_vector.begin(), real_vector.end());

目前，我已经将其转换为成对向量，然后将其转换为

节点

类型的向量，然后转换为

节点

类型的优先级队列

// this->char_freqs is of type map<std::string, int>
std::vector<std::pair<std::string, int> > my_vector(this->char_freqs.begin(), this->char_freqs.end());
  std::vector<Huffman::Node*> real_vector;
  for (unsigned int i = 0; i < my_vector.size(); ++i) {
    real_vector.push_back(new Huffman::Node(my_vector[i].first, my_vector[i].second));
  }
  std::priority_queue<Huffman::Node*, std::vector<Huffman::Node*>, Huffman::comp> PQ(real_vector.begin(), real_vector.end());

在阅读文档时，我只找到了将用户定义的类型转换为默认类型的示例，而不是相反的方法

编辑1

这应该更简单，并解释我在寻找什么

class Node {
 public:
  char character;
  int frequency;
  Node(char char_, int val_) {
    character = char_;
    frequency = val_;
  }
  operator std::pair<char, int>() {
    return std::pair<char, int>(character, frequency);
  }
};
int main(int argc, char** argv) {
  std::vector<std::pair<char, int> > my_vector_1;
  Node n('a', 3);
  my_vector_1.push_back(n); // Can use a Node as an input since the conversion has been explicitly defined

  std::vector<Node> my_vector_2;
  std::pair<char, int> pair('a', 3);
  my_vector_2.push_back(pair); // Invalid
}

类节点{
公众：
字符；
整数频率；
节点（char，int val）{
character=char；
频率=val_2;；
}
运算符std:：pair（）{
返回标准：：对（字符、频率）；
}
};
int main（int argc，字符**argv）{
std:：vector my_vector_1；
节点n（'a'，3）；
my_vector_1.push_back（n）；//可以使用节点作为输入，因为转换已明确定义
std:：vector my_vector_2；
标准：：成对（'a'，3）；
my_vector_2.向后推（对）；//无效
}

---

当然，无效选项将失败，因为编译器无法将对转换为节点，但是否有可能使无效行正常工作？

如果我正确理解您的问题，您需要的是

节点的另一个构造函数，类似这样的

Node(const std::pair<char, int>& pair) : character{pair.first}, 
                                         frequency{pair.second} { }

节点（const std:：pair&pair）：字符{pair.first}，
频率{pair.second}{

注意，我正在使用成员初始值设定项列表来初始化类的数据。这是推荐的方法，有关详细信息，请参阅

接下来，您可能希望将构造函数标记为
explicit
，以避免不必要的转换（请参阅），并使用
emplace\u back
而不是
push\u back
来避免临时构造函数的构造。将构造函数标记为显式的可能不适合您的用例，选择权在您。如果将构造函数标记为“显式”

“向后推”将停止工作，则需要显式创建一个

节点

或使用

emplace\u-back

，问题属于

隐式转换

隐式转换是根据复制初始化定义的：
如果类型为T的对象可以用表达式E进行复制初始化，则E隐式转换为T。


现在考虑下面的例子，

#include <iostream>
#include <utility>

class Point
{
public:
    Point():x(),y()
    {
    }

    Point( const std::pair< int, int>& pair):
        x( pair.first),
        y( pair.second)
    {

    }

    int getX() const
    {
        return x;
    }

    int getY() const
    {
        return y;
    }

private:
    int x;
    int y;
};

int main(int , char *[])
{
    Point p = std::pair< int, int>( 1, 2);
    std::cout<< "x = "<< p.getX()<< ", y = "<< p.getY()<< std::endl;

    return 0;
}


#包括
#包括
类点
{
公众：
点（）：x（），y（）
{
}
点（常数std:：pair&pair）：
x（第一对），
y（第二对）
{
}
int getX（）常量
{
返回x；
}
int getY（）常量
{
返回y；
}
私人：
int x；
int-y；
};
int main（int，char*[]）
{
点p=std：：对（1,2）；
std：：你似乎很了解你的问题。你能创建一个并发布它吗？是的，对不起。在StackOverflow上发布仍然是一种新方法。一种方法可以是用户定义的类型