c++stringclassraiiresource-management

No output from using array in class


I get a blank output. I'm a newbie and have been struggling on this for some time.
I have gotten 0 errors by the compiler.

Also what can be improved on this?

How can I get the length of const char* as an int instead of size_t without having to use 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;
}

Solution

  • I get a blank output.

    You don't fill your String::Str_Buffer with meaningful data in the constructor. You could use std::strcpy() from <cstring> to do that. std::strlen() is also declared in that header file. To use std::strcpy() the memory pointed to by String::Str_Buffer needs to be one char bigger than the string you want to copy there because strings in C and C++ are zero-terminated ('\0').

    How can I get the length of const char* as an int instead of size_t without having to use static_cast.

    Why would you want an int? Sizes of objects in C++ are measured with values of type std::size_t (defined in several headers but when in doubt include <cstddef>). std::size_t is guaranteed to be big enough to handle all object sizes. It is for example the return type of std::strlen() and the sizeof-operator.

    Your assignment operator is not 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
        // ...
    

    Possible but not elegant solution:

    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;
    }
    

    See Copy-and-Swap for an better solution.


    Resource Management

    Please familiarize yourself with The Rule of Five and the Copy-and-Swap Idiom.

    A starting point for a class that manages a string could look like that:

    #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';
    }