Question

我得到一个空白输出。我是新手，已经为此苦苦挣扎了一段时间。
编译器出现0错误。

还有什么可以改进的？

如何不必使用const char*就能将int的长度作为size_t而不是static_cast。

#include <iostream>
#include <cassert>

class String
{
private:
    char* Str_Buffer{};
    int Str_Size{};
public:
    String(const char* string = " ")
        : Str_Size{ static_cast<int>(strlen(string)) }
    {
        Str_Buffer = new char[Str_Size];
    }

    String& operator=(const String& string)
    {
        if (this == &string)
            return *this;

        delete[] Str_Buffer;

        Str_Size = string.Str_Size;
        if (string.Str_Buffer)
        {
            Str_Buffer = new char[Str_Size];

            for (int index{ 0 }; index < Str_Size; ++index)
                Str_Buffer[index] = string.Str_Buffer[index];
        }
        return *this;
    }

    char& operator[](const int index)
    {
        assert(index >= 0);
        assert(index < Str_Size);
        return Str_Buffer[index];
    }

    friend std::ostream& operator<<(std::ostream& out, const String& string)
    {
        out << string.Str_Buffer;
        return out;
    }

    ~String()
    {
        delete[] Str_Buffer;
    }
};

int main()
{
    String word("Hello world!");
    std::cout << word;

    return 0;
}

Answer 1

我得到一个空白输出。

您不会在构造函数中用有意义的数据填充String::Str_Buffer。您可以使用std::strcpy()中的<cstring>来做到这一点。在该头文件中也声明了std::strlen()。要使用std::strcpy()，指向String::Str_Buffer指向的内存必须比要复制的字符串大char一个'\0'，因为C和C ++中的字符串以零结尾（{{1} }。

如何不必使用const char*就能将int的长度作为size_t而不是static_cast。

您为什么要使用int？ C ++中对象的大小以std::size_t类型的值（在多个标头中定义，但有疑问时包括<cstddef>来衡量）。 std::size_t保证足够大以处理所有对象大小。例如，它是std::strlen()的返回类型和sizeof运算符。

您的分配运算符不是exception-safe：

String& operator=(const String& string)
{
    // ...

    delete[] Str_Buffer;  // the old state is now gone

    Str_Size = string.Str_Size;
    if (string.Str_Buffer)
    {
        Str_Buffer = new char[Str_Size];  // when new[] throws, the object
                                          // will be in an undefined state
    // ...

可能但不优雅的解决方案：

String& operator=(const String& string)
{
    char *temp = new[string.Str_Size];

    // copy string.Str_Buffer to temp

    delete[] Str_Buffer;
    Str_Buffer = temp;
    Str_Size string.Str_Size

    return *this;
}

有关更好的解决方案，请参见“复制和交换”。

资源管理

请熟悉The Rule of Five和Copy-and-Swap Idiom。

一个管理字符串的类的起点可能看起来像这样：

#include <cassert>   // assert()
#include <cstddef>   // std::size_t
#include <cstring>   // std::strlen(), std::strcpy()
#include <utility>   // std::swap(), std::exchange()
#include <iostream>

class string_t
{
    size_t  length  = 0;
    char   *data    = nullptr;

public:
    string_t() = default;

    string_t(char const *str)
    : length { str ? std::strlen(str) : 0  },
      data   { new char[length + 1]{}      }
    {
        str && std::strcpy(data, str);
    }

    string_t(string_t const &other)  // copy constructor
    : length { other.length            },
      data   { new char[length + 1]{}  }
    {
        other.data && std::strcpy(data, other.data);
    }

    string_t(string_t &&other)  // move constructor
    : length { std::exchange(other.length, 0)      },  // steal others resources and
      data   { std::exchange(other.data, nullptr)  }   // give other a state it's
    {}                                                 // destructor can work with

    string_t& operator=(string_t other)   // assignment operator
    {                                     // mind: other gets copied
        std::swap(length, other.length);  // steal other's resources
        std::swap(data, other.data);      // other's destructor will
    }                                     // take care of ours.

    ~string_t() { delete[] data; }

    std::size_t get_length() const { return length; }

    char& operator[](std::size_t index)
    {
        assert(index < length);
        return data[index];
    }

    // stream-insertion operator:
    friend std::ostream& operator<<(std::ostream &os, string_t const &str)
    {
        return os << (str.data ? str.data : "");
    }
};

int main()
{
    string_t foo{ "Hello!" };  // char const* constructor
    std::cout << foo << '\n';

    string_t bar{ foo };  // copy constructor
    std::cout << bar << '\n';

    string_t qux{ string_t{ "World!" } };  // move constructor (from a temporary)
    std::cout << qux << '\n';

    bar = qux;  // assignment operator
    std::cout << bar << '\n';
}

Answer 2

首先，您需要包含strlen。您将得到一个空白输出，因为构造函数未将输入字符串写入Str_Buffer。您可以使用std :: copy将内存复制到分配的缓冲区。

您必须使用静态转换，因为strlen返回std :: size_t。只需将Str_Size的类型更改为std :: size_t即可摆脱静态转换。

还要看看rule of five。定义移动复制构造器将提高代码的性能。

在下面查看代码的有效版本：

<routing-outlet></routing-outlet>

在类中使用数组无输出

2 个答案:

资源管理