c – 使用自定义类型的初始化列表重载>>运算符和初始化

我一直在尝试制作一个非常简单的地图容器,我认为能够像这样初始化它会很好：

Hash table = {  "name1" >> value,
                "name2" >> value2,
                "name3" >> value3,
                "name4" >> value4  };

我将如何解决这个问题的方法是首先制作一对(二重奏)数据结构
保留每个元素的名称和值,重载>> operator使用name和value参数返回duo,并使用initializer_list构造duo元素的向量,使哈希类的构造函数初始化它.然后使用二进制搜索方法检索所需元素.

不幸的是,我从一开始就碰壁了.
在我开始编码所有内容之前,我想确保正确使用重载,事实上这是一个明智的决定,因为显然它们不是.

这有效：

#include <iostream>
#include <string>
#include <vector>
#include <initializer_list>

struct duo {
  duo(const std::string key,int value) :key(key) ,value(value) {};
  const std::string key;
  int value;
};

struct Hash {
  std::vector<duo> lister;
  Hash(std::initializer_list<duo> passed) :lister(passed) {};
};

duo operator >> (const std::string& id,int value) {
  return duo(id,value);
}

int main(){
  duo object1("test",1);
  Hash table = {object1};
  std::cout << table.lister[0].key << table.lister[0].value;
}

但是这给了“类型’const char [6]’和’int’的无效操作数到二元’运算符>>’”

#include <iostream>
#include <string>
#include <vector>
#include <initializer_list>

struct duo {
  duo(const std::string key,int value) :key(key) ,value(value) {};
  const std::string key;
  int value;
};

struct Hash {
  std::vector<duo> lister;
  Hash(std::initializer_list<duo> passed) :lister(passed) {};
    };

duo operator >> (const std::string id,int value) {
  return duo(id,value);
}

int main(){
  Hash table = {"test1" >> 1};
  std::cout << table.lister[0].key << table.lister[0].value;
}

我试图将std :: string传递给>>运算符因为我不能用原始类型重载.看来这不是一个解决方案.有没有办法在没有明确地将字符串文字转换为std :: string的情况下实现所需的效果？

解决方法:

显式构造一个字符串将解决此问题：

int main(){
  Hash table = {std::string("test1") >> 1};
  std::cout << table.lister[0].key << table.lister[0].value;
}

我也有>>引用const字符串,而不是按值的字符串：

duo operator >> (const std::string& id,int value) {
  return duo(id,value);
}

您可能认为通过设计以下内容可以避免显式构造：

template <size_t N> duo operator >> (const char (&ary)[N], int id)
{
  return duo (std::string (ary), id);
}

…要么：

duo operator >> (const char* id, int value)
{
  return duo (std::string (id), value);
}

但你不能因为C不允许覆盖运算符>>用于指针(或任何原始)类型.如果你试试这个,你将得到编译器错误,“必须有类或枚举类型的参数”.为了提供运算符重载,必须至少提供一个类或枚举类型的参数.

所以让我们稍微考虑一下.我们不能使用operator<<有两个原始参数,因为这是不允许的.您真正需要的是干净的初始化语法,无需任何显式初始化.在我们的方式中唯一真正标准的是初始化.那么,如果我们尝试构建实际使用两个运算符但仍看起来干净的东西呢？如果我们尝试构建如下内容,该怎么办？

Hash table = {"test1" <MapTo> 1};

这不完全是你想要的语法,但它非常接近.所以让我们尝试构建这个：

这里有两个操作符：操作符<和运算符>.运算符的参数<是字符串文字“test1和一些名为MapTo的对象.运算符>的参数是任何运算符<返回和一个整数文字,1. 看操作符<首先,让我们破解一个原型：

template <size_t N> std::string operator < (const char (&ary)[N], Something op)

我们知道我们需要操作符>返回一个二人组,那么为了方便那些东西需要做些什么呢？我们真的需要操作符<要做的是将字符串文字转换为std :: string,所以让我们尝试：

class HashOperation
{
public:
  template <size_t N> std::string cvt (const char (&ary)[N]) const
  {
    return std::string (ary);
  }
} MapTo;


template <size_t N> std::string operator < (const char (&ary)[N], HashOperation op) 
{
  return op.cvt (ary);
}

现在我们有了std :: string,让我们和int一起构建一个二人组.

duo operator> (const std::string& key, int value)
{
  return duo (key, value);
}

这很简单.让我们把它们放在一起(Live Demo)：

#include <iostream>
#include <string>
#include <vector>
#include <initializer_list>

struct duo {
  duo(const std::string key,int value) :key(key) ,value(value) {};
  template <size_t N> duo (const char (&ary)[N], int value) : key (ary), value (value) {};
  const std::string key;
  int value;
};

struct Hash {
  std::vector<duo> lister;
  Hash(std::initializer_list<duo> passed) :lister(passed) {};
    };


class HashOperation
{
public:
  template <size_t N> std::string cvt (const char (&ary)[N]) const
  {
    return std::string (ary);
  }
} MapTo;


template <size_t N> std::string operator < (const char (&ary)[N], HashOperation op)
{
  return op.cvt (ary);
}

duo operator> (const std::string& key, int value)
{
  return duo (key, value);
}

int main(){
  Hash table =
  {
    "test1" <MapTo> 1,
    "test2" <MapTo> 2
  };

  std::cout << table.lister[0].key << table.lister[0].value;
}

标签：c,operator-overloading,initializer-list,map
来源： https://codeday.me/bug/20190722/1507720.html