What's wrong with my custom string class operator+?

I'm trying to make my own String class, and I have a problem with operator+.

When I use + as " s1 = s2 + s3 " it works.

But in case just use " s1 + s1 " or " s2 + s3 " does not work.

When I run it, I get 0xC0000005 error on 'init' function at delete[] str_; line.

I want to know what's wrong with my codes...

this is my string.h

class String 
{
private:    
    int len_;
    int capa_;
    char* str_;

public: 
String(const String& str);
String(const char* s = "");
~String();
const char* Print(bool show = true);
int size();
int length();
int capacity();

String& assign(const String& str);
String& assign(const char* s);
String& operator=(const String& str);
String& operator=(const char* s);
String& append(const String& str);
String& append(const char* s);
String& operator+=(const String& str);
String& operator+=(const char* s);
String operator+(const String& str);
String operator+(const char* s);


char& operator[](int index);
    void shrink_to_fit();
    friend std::ostream& operator<<(std::ostream& os, const String& str);

private:    
    void init(const char* s);
    String plus(const char* s);
};

this is my string.cpp

void String::init(const char* s)
{
    if (str_ == s) {}   
    else
    {
        delete[] str_;
    }
    len_ = strlen(s);
    capa_ = len_ + 1;
    str_ = new char[capa_];
    strcpy_s(str_, capa_, s);
}
String::String(const String& str)
{
    init(str.str_);
}
String::String(const char* s)
{
    init(s);
}
String::~String()
{
    delete[] str_;
}
int String::size()
{
    return this->len_;
}
int String::length()
{
    return strlen(this->str_);
}
int String::capacity()
{
    return this->capa_;
}

String& String::assign(const String& str)
{
    assign(str.str_);
    return *this;
}

String& String::assign(const char* s)
{
    init(s);
    return *this;
}

String& String::operator=(const String& str)
{
    assign(str.str_);
    return *this;
}

String& String::operator=(const char* s)
{
    assign(s);
    return *this;
}

String& String::append(const String& str)
{
    append(str.str_);
    return *this;
}

String& String::append(const char* s)
{
    len_ = this->len_ + strlen(s);
    capa_ = len_ + 1;
    char* temp = new char[capa_];

    strcpy_s(temp, capa_, this->str_);
    if (str_ == s) {}   
    else
    {
        delete[] str_;
    }
    strcat_s(temp, capa_, s);

    str_ = new char[capa_];
    strcpy_s(str_, capa_, temp);
    delete[] temp;

    return *this;
}

String& String::operator+=(const String& str)
{
    append(str);
    return *this;
}

String& String::operator+=(const char* s)
{
    append(s);
    return *this;
}

char& String::operator[](int index)
{
    int index_;
    if (index < 0)
    {
        index_ = 0;
    }
    else if (index > this->len_)
    {
        index_ = this->len_ - 1;
    }
    else
    {
        index_ = index;
    }

    return str_[index_];
}

String String::plus(const char* s)
{
    int tempcapa = this->len_ + strlen(s) + 1;
    char* temp = new char[tempcapa];
    strcpy_s(temp, tempcapa, this->str_);
    strcat_s(temp, tempcapa, s);

    return temp;
}

String String::operator+(const String& str)
{
    return plus(str.str_);
}
String String::operator+(const char* s)
{
    return plus(s);
}

std::ostream& operator<<(std::ostream& os, const String& str)
{
    os << str.str_;
    return os;
}

void String::shrink_to_fit()
{

    if (this->capa_ > this->len_ + 1)
    {
        char* temp = new char[len_ + 1];
        strcpy_s(temp, len_ + 1, this->str_);

        delete[] this->str_;

        this->str_ = new char[len_ + 1];
        strcpy_s(this->str_, len_ + 1, temp);
        delete[] temp;
        this->capa_ = len_ + 1;
    }
}

const char* String::Print(bool show)
{
    if (show == true)
        std::cout << str_;
    return str_;
}