Почему я не могу присвоить скалярное значение классу, используя сокращение, а вместо этого сначала объявить его, а затем установить его значение?

Question

Я пишу библиотеку UTF-8 для C ++ в качестве упражнения, так как это мой первый реальный код C ++. До сих пор я реализовал конкатенацию, индексацию символов, анализ и кодирование UTF-8 в классе под названием «ustring». Похоже, что это работает, но два, казалось бы, эквивалентных способа объявить новую ustring ведут себя по-разному. Первый способ:

ustring a;
a = "test";

работает, и перегруженный оператор "=" анализирует строку в классе (в котором строки Unicode хранятся в виде динамически размещаемого указателя int). Однако следующее не работает:

ustring a = "test";

потому что я получаю следующую ошибку:

test.cpp:4: error: conversion from ‘const char [5]’ to non-scalar type ‘ustring’ requested

Есть ли способ обойти эту ошибку? Это, вероятно, проблема с моим кодом, хотя. Вот что я написал для библиотеки:

#include <cstdlib>
#include <cstring>
class ustring {
  int * values;
  long len;
  public:
  long length() {
    return len;
  }
  ustring * operator=(ustring input) {
    len = input.len;
    values = (int *) malloc(sizeof(int) * len);
    for (long i = 0; i < len; i++)
      values[i] = input.values[i];
    return this;
  }
  ustring * operator=(char input[]) {
    len = sizeof(input);
    values = (int *) malloc(0);
    long s = 0;                                                                 // s = number of parsed chars
    int a, b, c, d, contNeed = 0, cont = 0;
    for (long i = 0; i < sizeof(input); i++)
      if (input[i] < 0x80) {                                                    // ASCII, direct copy (00-7f)
        values = (int *) realloc(values, sizeof(int) * ++s);
        values[s - 1] = input[i];
      } else if (input[i] < 0xc0) {                                             // this is a continuation (80-bf)
        if (cont == contNeed) {                                                 // no need for continuation, use U+fffd
          values = (int *) realloc(values, sizeof(int) * ++s);
          values[s - 1] = 0xfffd;
        }
        cont = cont + 1;
        values[s - 1] = values[s - 1] | ((input[i] & 0x3f) << ((contNeed - cont) * 6));
        if (cont == contNeed) cont = contNeed = 0;
      } else if (input[i] < 0xc2) {                                             // invalid byte, use U+fffd (c0-c1)
        values = (int *) realloc(values, sizeof(int) * ++s);
        values[s - 1] = 0xfffd;
      } else if (input[i] < 0xe0) {                                             // start of 2-byte sequence (c2-df)
        contNeed = 1;
        values = (int *) realloc(values, sizeof(int) * ++s);
        values[s - 1] = (input[i] & 0x1f) << 6;
      } else if (input[i] < 0xf0) {                                             // start of 3-byte sequence (e0-ef)
        contNeed = 2;
        values = (int *) realloc(values, sizeof(int) * ++s);
        values[s - 1] = (input[i] & 0x0f) << 12;
      } else if (input[i] < 0xf5) {                                             // start of 4-byte sequence (f0-f4)
        contNeed = 3;
        values = (int *) realloc(values, sizeof(int) * ++s);
        values[s - 1] = (input[i] & 0x07) << 18;
      } else {                                                                  // restricted or invalid (f5-ff)
        values = (int *) realloc(values, sizeof(int) * ++s);
        values[s - 1] = 0xfffd;
      }
    return this;
  }
  ustring operator+(ustring input) {
    ustring result;
    result.len = len + input.len;
    result.values = (int *) malloc(sizeof(int) * result.len);
    for (long i = 0; i < len; i++)
      result.values[i] = values[i];
    for (long i = 0; i < input.len; i++)
      result.values[i + len] = input.values[i];
    return result;
  }
  ustring operator[](long index) {
    ustring result;
    result.len = 1;
    result.values = (int *) malloc(sizeof(int));
    result.values[0] = values[index];
    return result;
  }
  char * encode() {
    char * r = (char *) malloc(0);
    long s = 0;
    for (long i = 0; i < len; i++) {
      if (values[i] < 0x80)
        r = (char *) realloc(r, s + 1),
        r[s + 0] = char(values[i]),
        s += 1;
      else if (values[i] < 0x800)
        r = (char *) realloc(r, s + 2),
        r[s + 0] = char(values[i] >> 6 | 0x60),
        r[s + 1] = char(values[i] & 0x3f | 0x80),
        s += 2;
      else if (values[i] < 0x10000)
        r = (char *) realloc(r, s + 3),
        r[s + 0] = char(values[i] >> 12 | 0xe0),
        r[s + 1] = char(values[i] >> 6 & 0x3f | 0x80),
        r[s + 2] = char(values[i] & 0x3f | 0x80),
        s += 3;
      else
        r = (char *) realloc(r, s + 4),
        r[s + 0] = char(values[i] >> 18 | 0xf0),
        r[s + 1] = char(values[i] >> 12 & 0x3f | 0x80),
        r[s + 2] = char(values[i] >> 6 & 0x3f | 0x80),
        r[s + 3] = char(values[i] & 0x3f | 0x80),
        s += 4;
    }
    return r;
  }
};

Answer 1

Ваша проблема в том, что ustring a = "test" фактически вызывает конструктор, а не оператор присваивания. да, добро пожаловать в c ++:)

Вам нужно определить и конструктор по умолчанию, и тот, который принимает const char*, потому что, как только вы определите конструктор, вам нужно будет определить все ваших конструкторов.

Несколько других вещей:

• передать ваш ввод по ссылке
• pass const char * вместо char[] (вы не изменяете ввод, и char * встречается чаще)
• sizeof не делает то, что вы думаете, он делает, не работает должным образом для параметров массива . Он возвращает вам sizeof(char*), а не sizeof(array).
• вернуть ссылку на this у своих операторов.
• вы можете использовать vector<int> values; для управления всей вашей памятью.
• encode(), вероятно, должно вернуть string. С string:
  • он управляет собственной памятью, поэтому вызывающему абоненту не нужно free или delete.
  • вы можете использовать s.append(c); вместо realloc.
  • вы можете использовать printf("%s", s.c_str());, но в c ++ вы обычно используете cout << s;
• рассмотрите возможность определения конструктора копирования.

Как это:

class ustring {
 public:
  // Default constructor, allows you to create your class with no arguments.
  ustring() { ...; }
  // Allows you to create your class from string literals.
  ustring(const char *input) { ...; }
  // Copy constructor, allows you to create your class from other instances.
  ustring(const ustring &input) { ...; }

  // Assignment operators.
  ustring &operator=(const ustring &input) { ...; return *this; }
  ustring &operator=(const char *input) { ...; return *this; }
};

int main() {
  ustring s, t;  // invokes default constructor.
  s = t;         // invokes ustring assignment op.
  s = "test";    // invokes const char* assignment op.
  ustring u = "test";  // invokes const char* constructor.
  ustring v("test");   // invokes const char* constructor.
  ustring x(u);  // invokes copy constructor.
}

Если это c ++, зачем ты все это делаешь с malloc / realloc? Я не полностью проанализировал этот код, но думаю, что есть более простой способ ... см. Комментарий об использовании вектора.

Как отметил @Michael Aaron Safyan в комментариях, если вы делаете какое-либо выделение памяти для класса ustring, вы захотите освободить его в деструкторе. Тем не менее, я думаю, что переключаясь на управляемые памятью контейнеры - vector & string - вы избежите какого-либо собственного управления памятью и сможете избежать написания деструктора.

Answer 2

Это две операции:

ustring a; // construct a new object using constructor
a = "test"; // assign value to object using operator=

Это одна операция:

ustring a = "test"; // construct with a value, aka value-intialization

В интересах эффективности времени выполнения и обеспечения семантической свободы C ++ не экстраполирует конструктор по умолчанию ustring::ustring() и оператор присваивания ustring::operator=(const char*) в конструктор ustring::ustring(const char *).

Но для большинства разумных строковых классов это будет работать:

ustring::ustring(const char *str)
 : /* initialize ustring::ustring() does */ {
    /* do whatever ustring::ustring() does */
    *this = str; // assign value.
}

Лучше вызвать оператор присваивания из конструктора, чем пытаться выполнить его наоборот.

Конечно, вы, вероятно, можете повысить эффективность, учитывая длину данной строки при выполнении инициализации.