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

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