Перегрузка оператора C ++ [], где параметр данных назначать?

Question

Я хочу добавить перегрузку оператора [] в моем классе.Перегрузка операторов - это не то, что мне приходилось делать раньше.

Я хочу написать реализацию, которая сделает следующее:

    myclass a;
    a["test"] = 123;
    int test = a["test"];      

Пока в моем классе прототип выглядит так:

    string operator[](const char* cpszLabel);

Реализация не завершена и выглядит следующим образом:

    string myclass::operator[](const char* cpszLabel) {
        string strContent;
        if ( cpszLabel != nullptr ) {
        }
        return strContent;
    }

В чем я не уверен, так это в том, как ссылаться на назначаемые данные или для этого требуетсяПерегрузка '=' тоже?

Я добавил перегрузку для оператора '=', но это не вызывается:

Прототип:

    string operator=(int intData);

Реализация:

    string myclass::operator=(int intData) {
        char szString[24];
        sprintf(szString, "\"%d\"", intData);
        return string(szString);
    }

Answer 1

Вам нужно организовать вещи так, чтобы operator[](const char* cpszLabel) возвращал ссылку на что-то в вашем классе.

int& operator[](const char* cpszLabel);

, вероятно, лучший прототип.

Затем вы можете изменить это "что-то" в вашем классе с помощью этой ссылки.Если честно, то, что вы хотите, можно достичь с помощью

typedef std::map<std::string, int> myclass;

, и большинство людей не беспокоится о typedef, особенно теперь, когда у нас есть auto.Если вы хотите использовать std::map в качестве переменной-члена в классе (для уменьшения функциональности и т. Д.), То отправной точкой будет следующее:

class myclass
{
    std::map<std::string, int> m_data;
public:
    int& operator[](const char* cpszLabel)
    {
        return m_data[cpszLabel];
    }
};

Answer 2

В a["test"] = 123; «получателем» назначения является объект, который возвращается из поиска, то есть string.
Вы не можете перегрузить оператор присваивания string.

Но, как известно, каждая проблема может быть решена путем введения уровня косвенности.

Вы можете хранить собственный тип вместо std::string, и позволить этому обрабатывать преобразование.

Очень маленький пример в качестве иллюстрации:

struct Data
{
    template<typename T>
    Data& operator=(const T& rhs)
    {
        std::ostringstream os;
        os << rhs;
        value = os.str();
        return *this;
    }
    operator const char*() const { return value.c_str(); }
    std::string value;
};

struct Container
{
    Data& operator[] (const std::string& s) { return table[s]; }
    std::map<std::string, Data> table;
};

int main()
{
    Container cont;
    cont["foo"] = "bar";
    cont["baz"] = 123;
    cont["goo"] = 5.5;
    for (auto v: cont.table)
    {
        std::cout << v.first << " --> " << v.second << '\n';
    }
}

Выход:

baz --> 123
foo --> bar
goo --> 5.5