Свой класс string, нужна помощь с перегрузкой операторов

#include <iostream>
#include <string.h>
#include <stdlib.h>
#include <locale.h>
#include <malloc.h>
 
namespace str
{ 
struct string
{
private:
#pragma region ========================== Variable ==============================
    typedef struct 
    { 
        char *p_str; 
        size_t length;
    }stringA;
 
    stringA str{};
    const type_info& ti_c = typeid(const_cast<const char * >(str.p_str));
 
#pragma endregion 
 
#pragma region ========================== Private Function ==============================
_inline void clr()
{
    if(str.p_str)           free(str.p_str);    
    str.p_str = nullptr;    str.length = 0U;  
}
//------------------------------------------------------------------
_inline bool __type_c(const type_info& ti){return ti_c == ti;}
 
#pragma endregion 
 
 
public:
 
#pragma region ==================================== Constructor ======================================
/* Конструктор однобайтовые символы */
string(const char *p_str)
{   
    clr();
 
   // if(p_str){
        if((str.length = strnlen_s(p_str, SIZE_MAX) ) > 0U)
        { 
            if(str.p_str  = static_cast<char *>(malloc(sizeof(char) * (str.length + 1) ) ) ) 
            {
                strncpy_s(str.p_str, str.length + 1, p_str, _TRUNCATE); 
                str.p_str[str.length] = '\0'; 
                
            }
        }else{  str.p_str   = static_cast<char *>       (calloc(1, sizeof(char) ) );}
                
   // }
}
//------------------------------------------------------------------
 
/* Конструктор по умолчанию */
explicit string(){     
    clr();
    str.p_str   = static_cast<char *>       (calloc(1, sizeof(char) ) ); 
}
 
//------------------------------------------------------------------
/* Конструктор копирования */
string(const string& s) 
{
   // if(s.c_str() == ""){  str.p_str   = static_cast<char *>       (calloc(1, sizeof(char) ) );}else{
 
    clr();
 
    if ((str.length = strnlen_s(s.c_str(), SIZE_MAX)) > 0U) {
        if ((str.p_str = static_cast<char *>    (malloc(sizeof(char) * (str.length + 1) ) ) ) != nullptr) {
    
                strncpy_s(str.p_str, str.length + 1, s.c_str(), _TRUNCATE);
                str.p_str[str.length] = '\0';    
         }
     }
    //}     
}
 
//------------------------------------------------------------------
/* Конструктор перемещения */
string(string &&moved)  noexcept  // ссылка rvalue       
{
    str.p_str = moved.str.p_str;   
    str.length = moved.str.length;
    moved.str.p_str = nullptr;
     
  //  if(str.p_str == nullptr){  str.p_str   = static_cast<char *>       (calloc(1, sizeof(char) ) ); str.length=0U;}
}
 
//------------------------------------------------------------------
~string(){  clr();  }
 
#pragma endregion
 
#pragma region ====================================== Class Members =======================================
//------------------------------------------------------------------
_inline size_t length() const { return str.length ; }
 
//------------------------------------------------------------------
_inline size_t string_size() const  {   
       return (str.p_str == nullptr) ? 0U : ((str.length +  1) * sizeof(char));    
}
 
//------------------------------------------------------------------
/* Добавляем строку с реолакацией памяти */
void add(const char *p_str_in)
{   
    size_t l = 0U;
   // if(str.p_str == nullptr) return;    
   
    if ((l = strnlen_s(p_str_in, SIZE_MAX)) != 0U) {
        if ((str.p_str = static_cast<char *> (realloc(str.p_str, (str.length + l + 1) * sizeof(char) ) ) ) != nullptr) {
            
            if(!strcat_s(str.p_str, str.length + l + 1, p_str_in)) str.length += l;
            str.p_str[str.length] = '\0';
        }//else{  str.p_str   = static_cast<char *>       (calloc(1, sizeof(char) ) ); str.length=0U;}
    }
}
 
//------------------------------------------------------------------
_inline const char* c_str() const {
    return ((str.p_str != nullptr) ? str.p_str : const_cast< char * >(""));
}
 
//------------------------------------------------------------------
/* Вывести символ в строке по индексу от нуля до str.length - 1 */
_inline char ch_at(size_t index) const  {
        return (/*(str.p_str != nullptr) && */(index < str.length)) ? str.p_str[index] : '\0';
}
 
//------------------------------------------------------------------
/* Заменить символ встроке по индексу от нуля до str.length - 1 */
_inline void ch_set_at(size_t index, char ch)   {
            if(/*(str.p_str != nullptr) && */(index < str.length))  str.p_str[index] = ch;
}
//------------------------------------------------------------------
_inline void clear(){ str.p_str   = static_cast<char *>       (calloc(1, sizeof(char) ) ); str.length = 0U;}
 
 
#pragma endregion
 
#pragma region ====================================== Operator Reload ============================================
//------------------------------------------------------------------
 string& operator +=(string const &s )  {      
            this->add(const_cast<char *>(s.c_str()));
            return  *this;
}
 
//------------------------------------------------------------------
  string& operator +=(char *s )    {      
        this->add(static_cast<char *>(s));  
        return  *this;
}
 
//------------------------------------------------------------------
const auto& operator = (const string& s)
{      
   // if (s.c_str() == "")return this;
    clr();
    if ((str.length = strnlen_s(s.c_str(), SIZE_MAX)) != 0U) {
        if ((str.p_str = static_cast<char *>(malloc(sizeof(char) * (str.length + 1) ) ) ) != nullptr) {
    
                strncpy_s(str.p_str, str.length + 1, s.c_str(), _TRUNCATE);
                str.p_str[str.length] = '\0'; 
         }
     }                  
return this;
 
}
 
#pragma endregion
 
//------------------------------------------------------------------ 
 friend std::ostream &operator <<(std::ostream &ostr, string const &point) { ostr << point.c_str(); return ostr; }
 
/* Конец string  */
};
 
//------------------------------------------------------------------
const string operator + (const string &L, const string &R){ return string(L) += R;}    
 
/* Конец области str:: */
};
 
//

#include <iostream>
 
inline int some_junk(int a, int b) {
    return a * b;
}
 
int main() {
    std::cout << some_junk(10, 10);
}

friend bool operator < (const string& l, const string& r)noexcept
{
   реализация
}
 
friend bool operator == (const string& l, const string& r)noexcept
{
   реализация
}

***
str::string str("Привет ");
***
где-то в цикле... 
if(str[i] == 'и')
***

namespace str
{
 
class string
{
private:
const size_t size_string = _MAX_PATH * sizeof(char);
 
struct stringA
    { 
    private:    
        explicit    stringA(const stringA&)     = delete;    
        stringA&    operator=(const stringA&)   = delete;        
    public:  
        ~stringA(){;}
         stringA(void) : length(0U), size_str(0U), p_str(nullptr) {} 
 
        size_t length;      /* Количество символов в строке */
        size_t size_str;    /* Размер выделенной памяти для строки */     
        char *p_str;        
 
    };  stringA str;