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

@Signum7 · Регистрация: 30.03.2017

Студворк — интернет-сервис помощи студентам

Доброго времени суток.
Создал свой класс string. Цель создания своего класса строк - это скорость работы со строками и второе в образовательных целях. Если реализация получится удачной сделаю библиотеку для личного использования. Сейчас реализованы строки типа char потом добавлю wchar_t. new и delete решил не использовать, так как использую простой тип char. Вроде утечек памяти нет, а работать в теории должно быстрее. Прошу просмотреть код и дать рекомендации по оптимизации или указать на ошибки в коде, буду очень признателен. У меня возник вопрос с перегрузкой операторов, не понимаю как их сделать правильно, представленная реализация вроде работает правильно. Подскажите как правильно перегрузить [], +=, =, +. За ранее благодарю за ответы.

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
#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:: */
};
 
//

@Signum7 · 18.01.2024, 21:06 **[ТС]**

Сообщение от DrOffset

Signum7, что-то наподобие этого хотели?

C++
1
2
3
4
5
6
7
8
9
10
11
template <class T = char> 
T* custom_memset(T* destination, unsigned char val, size_t size = 1) 
{
    unsigned char* dest = reinterpret_cast<unsigned char*>(destination);
    size *= sizeof(T);
    while(size-- > 0) 
    {
       *dest++ = val;
    }
    return destination;
}

* __cdecl - не нужен. Читайте про соглашения о вызовах;
* unsigned char, раз уж вы внутри в него кастить собрались, проще сразу получать в параметре;
* отдельная функция каста - не нужна. Даже если вы ее напишете, она будет повторять семантику и поведение встроенного каста, и вызов ее будет точно таким же, только вместо reinterpret_cast будет имя вашей функции, т.е. все это будет избыточно;
* раз мы принимаем T*, значит size может быть размером последовательности этих T, поэтому, раз уж вы работаете с байтами, нужно будет домножить на sizeof(T);
* эта функция имеет смысл только для самообразования, потому что ей никогда не обогнать стандартный memset во многих кейсах, потому что стандартный memset - это не только функция, но и intrinsic компилятора.

О благодарю реализация оказалась проще чем я думал

@Signum7 · 19.01.2024, 17:33 **[ТС]**

Подскажите как правильно сделать проверку char или wchar_t правильно. В качестве типа использовать только эти типы.
Что-то типа такого:

C++
1
2
3
4
5
template<class T = char> 
class string
***
assert(bad_type(T) != nullptr); 
***

@SmallEvil · 19.01.2024, 18:09

Signum7, static_assert плюс is_same

@Signum7 · 19.01.2024, 19:24 **[ТС]**

Сообщение от SmallEvil

Signum7, static_assert плюс is_same

Благодарю сделал так:

C++
1
2
3
4
5
6
#include <type_traits>
template <class T = char> 
void foo()
{
    static_assert( (std::is_same_v<T,char> ? true : std::is_same_v<T,wchar_t> ? true : false )," Err Type ");
}

@DrOffset · 19.01.2024, 19:33

Сообщение от Signum7

(std::is_same_v<T,char> ? true : std::is_same_v<T,wchar_t> ? true : false)

Зачем такое городить?

C++
1
static_assert(std::is_same_v<T,char> || std::is_same_v<T,wchar_t>, " Err Type ");

@Signum7 · 19.01.2024, 19:38 **[ТС]**

Сообщение от DrOffset

static_assert(std::is_same_v<T,char> || std::is_same_v<T,wchar_t>, " Err Type ");

А я так сначала и сделал, но мне показалось как-то не интересно и переделал на тот вариант который выставил на форум

@DrOffset · 19.01.2024, 19:52

Signum7, через задницу и само без усилий получится, а специально лучше так не делать

@TheCalligrapher · 20.01.2024, 02:15

Сообщение от Signum7

C++
1
2
3
4
5
template <class T = char> 
void foo()
{
    static_assert( (std::is_same_v<T,char> ? true : std::is_same_v<T,wchar_t> ? true : false )," Err Type ");
}

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <type_traits>
 
template <class T = char> 
void foo() requires(std::is_same_v<T, char> || std::is_same_v<T, wchar_t>)
{
}
 
int main() 
{
  foo();
  foo<>(); 
  foo<char>();
  foo<wchar_t>();
  foo<int>(); // ERROR
}

@Signum7 · 20.01.2024, 18:36 **[ТС]**

Сообщение от TheCalligrapher

requires(std::is_same_v<T, char> || std::is_same_v<T, wchar_t>)

чем лучше static_assert есть ли смысл включать с++20 для моего проекта?

@SmallEvil · 20.01.2024, 20:37

Signum7, static_assert доступен с C++11.
C++ - статически типизированный ЯП. То есть, ошибка будет обнаружена на этапе компиляции, с assert , только в режиме выполнения и только в отладочном режиме, в релизе его не будет.
Ну а requiers, да с 20, приведен как возможность современног C++.
Вопрос нужен ли вам вообще С++?

@Signum7 · 20.01.2024, 20:44 **[ТС]**

Сообщение от SmallEvil

Signum7, static_assert доступен с C++11.
C++ - статически типизированный ЯП. То есть, ошибка будет обнаружена на этапе компиляции, с assert , только в режиме выполнения и только в отладочном режиме, в релизе его не будет.
Ну а requiers, да с 20, приведен как возможность современног C++.
Вопрос нужен ли вам вообще С++?

Тогда посоветуйте мне изучаю с++, стоит ли тогда его изучать с упором на с++20 или для начинающих не стоит на него пока переходить а использовать возможности старых версий 14++ 17++

@TheCalligrapher · 20.01.2024, 20:49

Сообщение от Signum7

чем лучше static_assert есть ли смысл включать с++20 для моего проекта?

Это разные вещи. static_assert - это пост-проверка. То есть ваша шаблонная функция всегда существует, но если вы вызовете ее неправильно, то произойдет ошибка.

requires - это constraint. Это пре-проверка, которая принимается во внимание в процессе overload resolution. В результате для неправильного набора шаблонных параметров такой функции не будет существовать вообще (или может правильнее сказать, что для неправильного набора шаблонных параметров она будет невидимой).

Constraints - развитие идеи SFINAE и в частности std::enable_if. То есть того же самого вы могли добиться и в С++11, используя std::enable_if вместо requires

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <type_traits>
 
template <class T = char> 
typename std::enable_if<std::is_same<T, char>::value || std::is_same<T, wchar_t>::value>::type foo()
{
}
 
int main() 
{
  foo();
  foo<>(); 
  foo<char>();
  foo<wchar_t>();
  foo<int>(); // ERROR
}

То есть C++20 тут совсем не обязателен. А дальше уже решайте, что вам больше нравится: пре-проверка или пост-проверка.

@Signum7 · 20.01.2024, 21:42 **[ТС]**

Сделал такие функции для своего класса вместо перегрузки strcpy_s wcscpy_s решил сделать свои шаблонные. не хочу UB b прочую гадость посмотрите пожалуйста.

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
//------------------------------------------------------------------
/* Длина строки (количество символов без нуля) */
template <class T = char> 
size_t custom_strnlen(const T* str ) requires(std::is_same_v<T, char> || std::is_same_v<T, wchar_t>)/* тут проверил requires*/
{  
   assert(str != nullptr);    
   size_t length = 0;
   while (*str++ != 0) length++;
 
   return length;
};
 
//------------------------------------------------------------------
/*  */
template <class T = char> /* Функция копирует указанное число символов из строки с завершающим нулем,  mem - размер памяти */
void  custom_strncpy_s(T* destination, const T* strc, size_t size = 0U,  size_t mem = SIZE_MAX)
{
 // size_t str_length = size > 0 ? size  : 1U;
 
  assert((destination != nullptr) || (strc != nullptr));
 
  if (size < mem) {
        while (size-- && (*destination++ = *strc++));
        *destination = 0;
    }
}
//------------------------------------------------------------------
template <class T = char>  /* Функция склеивает указанное число символов из строки с завершающим нулем,  mem - размер памяти */
void custom_strncat_s(T* destination, const T* strc, size_t size = 0U , size_t mem = SIZE_MAX)
{
    assert((destination != nullptr) || (strc != nullptr));  
    if (!(size < mem))return ;
 
    size_t str_length = custom_strnlen<T>(destination); 
 
    size_t tmp = ((tmp = size + str_length) < mem) ? size : mem - str_length ;
 
    T* ptr = destination + str_length;
    
    while (*strc != 0 && tmp-- )
    {
        *ptr++ = *strc++;
    }*ptr = 0; 
}
 
template <class T = char>  
void custom_strncat_s(T* destination, size_t size1  ,const T* strc, size_t size2 = 0U , size_t mem = SIZE_MAX)
{
    assert((destination != nullptr) || (strc != nullptr));  
    if (!((size1 + size2) < mem))return ;
 
    T* ptr = destination + size1;
    
    while (*strc != 0 && size2-- )
    {
        *ptr++ = *strc++;
    }*ptr = 0; 
}
 
 
//------------------------------------------------------------------
template <class T = char> 
int custom_cscmp(const T* str1, const T* str2) 
{
    assert((str1 != nullptr) || (str2 != nullptr));
    while ( *str1 && *str2 && *str1 == *str2 ) ++str1, ++str2;       
    return *str1 - *str2;
}

Добавлено через 15 минут

Сообщение от TheCalligrapher

То есть C++20 тут совсем не обязателен. А дальше уже решайте, что вам больше нравится: пре-проверка или пост-проверка.

для случая str != nullptr, что лучше?

Добавил еще такую функцию

C++
1
2
3
4
5
6
7
8
9
template <class T = char> 
inline static void str_cat(T* destination, size_t size1  , const T* strc, size_t size2){
    T* ptr = destination + size1;
    
    while (*strc != 0 && size2-- )
    {
        *ptr++ = *strc++;
    }*ptr = 0; 
}

Это чтобы не дублировать код

@TheCalligrapher · 20.01.2024, 23:02

Сообщение от Signum7

для случая str != nullptr, что лучше?

Не совсем понимаю, при чем здесь str != nullptr. str != nullptr - это, естественно, проверка именно времени выполнения, которая никакого отношения ни к каким static_assert/requires/stf::enable_if не имеет вообще.

@Signum7 · 21.01.2024, 01:50 **[ТС]**

То что на данный момент

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
/* Класс string только для строк  char или wchar_t */
template<class T = char> 
class string 
{static_assert(std::is_same_v<T,char> || std::is_same_v<T,wchar_t>, " Err Type ");
private:
 
//------------------------------------------------------------------
private:
 
        size_t  leng{0U};           /* Количество символов в строке */
        size_t  size_str{0U};       /* Размер выделенной памяти для строки */     
        T       *p_str{nullptr};    /* Строка */
 
//------------------------------------------------------------------
void realloc_foo(size_t &len)
{
        T *p_str_t = nullptr; if (len == leng)return;        
        
        if ((p_str_t = static_cast<T *> (realloc(p_str, (leng + len + 1) * sizeof(T)))) != nullptr) p_str = p_str_t;
             p_str_t = nullptr;             
        
}
 
//------------------------------------------------------------------
void malloc_foo(size_t &len)
{   
        T *p_str_t = nullptr;
        if ((p_str_t = static_cast<T *>(malloc(sizeof(T) * (len + 1) ) ) ) != nullptr) p_str = p_str_t;
             p_str_t = nullptr;                   
}
 
//------------------------------------------------------------------
void construct(const T *pstr) {
          
        assert(pstr != nullptr);
        if((leng = custom_strnlen<T>(pstr) ) > 0U) { malloc_foo(leng); /*assert(p_str != nullptr);*/
                   custom_strncpy_s<T>(p_str,pstr,leng);
        }
}
//------------------------------------------------------------------
public:
 
/* Конструктор символы */
 string(const T *pstr) {
            assert(pstr != nullptr);std::cout << " Конструктор символы " << std::endl; 
            if((leng = custom_strnlen<T>(pstr) ) > 0U) { malloc_foo(leng); /*assert(p_str != nullptr);*/
                    custom_strncpy_s<T>(p_str,pstr,leng);
            }  
 }
 
//------------------------------------------------------------------
 
/* Конструктор по умолчанию */
string() { p_str = static_cast<T *> (calloc(1, sizeof(T) ) ); size_str = 1; }
 
//------------------------------------------------------------------
/* Конструктор копирования */
string(const string& s) {
    std::cout << " Конструктор копирования " << std::endl; 
    construct(s.p_str);
    /* не работает */
    //size_t l = s.leng;malloc_foo(l); /*assert(p_str != nullptr);*/
    //custom_strncpy_s<T>(p_str, s.p_str, l);
}
 
//------------------------------------------------------------------
/* Конструктор перемещения */
string(string &&moved) noexcept 
{  std::cout << " Конструктор перемещения " << std::endl; 
            size_str        = moved.size_str;          
            p_str           = moved.p_str;   
            leng            = moved.leng;
            moved.p_str     = nullptr;
            moved.size_str  = moved.leng = 0U; 
}
 
//------------------------------------------------------------------
~string() noexcept {
            if(p_str != nullptr)    free(p_str);    
            p_str = nullptr;        size_str = leng = 0U;  
}
 
//------------------------------------------------------------------
size_t length() const { return leng ; }
 
//------------------------------------------------------------------
size_t string_size() const  {   
            return (p_str == nullptr) ? 0U : ((leng +  1) * sizeof(T));    
}
 
//------------------------------------------------------------------
/* Добавляем строку с реолакацией памяти */
 
void add(const T *p_str_in)
{  
    assert(p_str_in != nullptr || p_str != nullptr); size_t l = 0;
   std::cout << " add ch " << std::endl; 
     if ((l = custom_strnlen<T>(p_str_in)) != 0U) { 
            realloc_foo(l); 
            custom_strncat_s<T>(p_str, leng, p_str_in, l); leng += l;          
        }    
}
//------------------------------------------------------------------
void add(const string& s)
{   std::cout << " add string " << std::endl;  
    size_t l = s.leng ; realloc_foo(l); 
    custom_strncat_s<T>(p_str,leng,s.p_str,l); 
}
//------------------------------------------------------------------
const T* c_str() const { return (p_str != nullptr) ? p_str : 0; }
 
//------------------------------------------------------------------
void clear() { }
 
//------------------------------------------------------------------
string &operator += (string const &s )  { add(s); return  *this; }
 
string &operator += (const T *str )     { add(str); return  *this; }
 
//------------------------------------------------------------------
const string &operator = (const string & s) {            
                string tmp(s); swap (*this, tmp); 
                return *this;
}
//------------------------------------------------------------------
string &operator = (string&& moved) noexcept            { swap (*this, moved); return *this; }
 
//------------------------------------------------------------------ 
        string &operator[]  (const size_t index)        { assert(index < leng); return p_str[index]; }
 const   string &operator[] (const size_t index) const  { assert(index < leng); return p_str[index]; }
        string *operator->  ()                          { return this; }
 
//------------------------------------------------------------------ 
 friend std::wostream &operator <<  (std::wostream &ostr,   string<T> const &str)   {ostr << str.c_str(); return ostr;}
 friend std::wistream &operator >> (std::wistream &in,  string<T>           &str)   {}
 
 friend std::ostream &operator << (std::ostream &ostr,  string<T> const &str)       {ostr << str.c_str(); return ostr;}
 friend std::istream &operator >> (std::istream &in,    string<T>           &str)   {}
 
 friend  const string operator + (const string<T> &l, const string<T> &r)                   {return string<T>(l) += r;} 
 //------------------------------------------------------------------ 
 friend void swap (string &l, string &r)
    {
        std::swap (l.p_str ,    r.p_str);
        std::swap (l.leng ,     r.leng);
        std::swap (l.size_str , r.size_str);
    }
 //------------------------------------------------------------------ 
friend bool operator <  (const string &l, const string &r) noexcept {/**/}
 
friend bool operator >  (const string &l, const string &r) noexcept {/**/}
 
friend bool operator == (const string &l, const string &r) noexcept {/**/}
 
 
//------------------------------------------------------------------ 
 
/* Конец string  */
};

@sdf45 · 21.01.2024, 02:02

Сообщение от Signum7

string &operator[]

а разве не Т &operator[] ?

@Signum7 · 21.01.2024, 06:05 **[ТС]**

Сообщение от sdf45

а разве не Т &operator[] ?

Да вот исправленный кусок

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
//------------------------------------------------------------------ 
         T &operator[]  (const size_t index)        { assert(index < leng); return p_str[index]; }
 const   T &operator[]  (const size_t index) const  { assert(index < leng); return p_str[index]; }
        string *operator->  ()                          { return this; }
 
//------------------------------------------------------------------ 
 friend std::wostream &operator <<  (std::wostream &ostr,   string<T> const &str)   {ostr << str.c_str(); return ostr;}
 friend std::wistream &operator >> (std::wistream &in,  string<T>           &str)   {}
 
 friend std::ostream &operator << (std::ostream &ostr,  string<T> const &str)       {ostr << str.c_str(); return ostr;}
 friend std::istream &operator >> (std::istream &in,    string<T>           &str)   {}
 
 friend  const string operator + (const string<T> &l, const string<T> &r)                   {return string<T>(l) += r;} 
 //------------------------------------------------------------------ 
 friend void swap (string<T> &l, string<T> &r)
    {
        std::swap (l.p_str ,    r.p_str);
        std::swap (l.leng ,     r.leng);
        std::swap (l.size_str , r.size_str);
    }
 //------------------------------------------------------------------ 
friend bool operator <  (const string<T> &l, const string<T> &r) noexcept {/**/}
 
friend bool operator >  (const string<T> &l, const string<T> &r) noexcept {/**/}
 
friend bool operator == (const string<T> &l, const string<T> &r) noexcept {/**/}
 
 
//------------------------------------------------------------------

Добавлено через 3 часа 51 минуту
Вот полностью рабочий класс проверьте пожалуйста, буду признателен. Уже глаза замылились нечего не вижу.

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
#include <iostream>
#include <locale.h>
#include <malloc.h>
#include <type_traits>
#include <cassert>
 
 
namespace str
{
//#define SIZE 10000
 
constexpr   size_t  TRUNCATE = ((size_t)-1);
constexpr   bool STACK_STRING = false ;
#ifndef SIZE
constexpr   size_t SIZE_STRING = 260 ; /* символов */
#else
constexpr   size_t SIZE_STRING = SIZE ;
#if (SIZE < 260)
constexpr   bool STACK_STRING = true ; /* Возможно для маленьких строк сделаю на стеке */
#else
constexpr   bool STACK_STRING = false ;
#endif
#endif
 
//------------------------------------------------------------------
/* Длина строки (количество символов без нуля) */
template <class T = char> 
inline size_t custom_strnlen(const T* str,size_t mem = SIZE_MAX )
    requires(std::is_same_v<T, char> || std::is_same_v<T, wchar_t>)
{  
   assert(str != nullptr);    
   size_t length = 0;
   while (*str++ != 0) length++;
 
   return length;
};
 
//------------------------------------------------------------------
/*  */
template <class T = char> /* Функция копирует указанное число символов из строки с завершающим нулем,  mem - размер памяти */
inline void  custom_strncpy_s(T* destination, const T* strc, size_t size = 0U,  size_t mem = SIZE_MAX) 
    requires(std::is_same_v<T, char> || std::is_same_v<T, wchar_t>)
{
  assert((destination != nullptr) || (strc != nullptr));
 
  if (size < mem) {
        while (size-- && (*destination++ = *strc++));
        *destination = 0;
    }
}
//------------------------------------------------------------------
template <class T = char> 
inline static void str_cat(T* destination, size_t size1  , const T* strc, size_t size2)
    requires(std::is_same_v<T, char> || std::is_same_v<T, wchar_t>)
 
{
    T* ptr = destination + size1;
    
    while (*strc != 0 && size2-- )
    {
        *ptr++ = *strc++;
    }*ptr = 0; 
}
//------------------------------------------------------------------
template <class T = char>  /* Функция склеивает указанное число символов из строки с завершающим нулем,  mem - размер памяти */
inline void custom_strncat_s(T* destination, const T* strc, size_t size = 0U , size_t mem = SIZE_MAX)
    requires(std::is_same_v<T, char> || std::is_same_v<T, wchar_t>)
{
    assert((destination != nullptr) || (strc != nullptr));  
    if (!(size < mem))return ;
 
    size_t str_length = custom_strnlen<T>(destination); 
 
    size_t tmp = ((tmp = size + str_length) < mem) ? size : mem - str_length ;
    str_cat(destination, str_length, strc, tmp);
}
//------------------------------------------------------------------
template <class T = char>  
inline void custom_strncat_s(T* destination, size_t size1  ,const T* strc, size_t size2 = 0U , size_t mem = SIZE_MAX)
    requires(std::is_same_v<T, char> || std::is_same_v<T, wchar_t>)
{
    assert((destination != nullptr) || (strc != nullptr));  
    if (!((size1 + size2) < mem))return ;
 
    str_cat(destination, size1, strc, size2);
}
 
//------------------------------------------------------------------
template <class T = char> 
inline int custom_cscmp(const T* str1, const T* str2) 
    requires(std::is_same_v<T, char> || std::is_same_v<T, wchar_t>)
{
    assert((str1 != nullptr) || (str2 != nullptr));
    while ( *str1 && *str2 && *str1 == *str2 ) ++str1, ++str2;       
    return *str1 - *str2;
}
 
//===================================================================================================================
/* Класс string только для строк  char или wchar_t */
template<class T = char> 
class string 
{static_assert(std::is_same_v<T,char> || std::is_same_v<T,wchar_t>, " Err Type ");
private:
 
//------------------------------------------------------------------
private:
 
        size_t  leng{0U};           /* Количество символов в строке */
        size_t  size_str{0U};       /* Размер выделенной памяти для строки */     
        T       *p_str{nullptr};    /* Строка */
 
//------------------------------------------------------------------
void realloc_foo(size_t len)
{
        T *p_str_t = nullptr; if (len + 1 == size_str)return;
 
        if(len < SIZE_STRING) size_str = SIZE_STRING; else size_str = len + 1;
 
        if ((p_str_t = static_cast<T *> (realloc(p_str, (size_str) * sizeof(T)))) != nullptr) p_str = p_str_t;
             p_str_t = nullptr; assert(p_str != nullptr); 
}
 
//------------------------------------------------------------------
void malloc_foo(size_t len)
{   if(len < SIZE_STRING) size_str = SIZE_STRING; else size_str = len + 1;
        T *p_str_t = nullptr;
        if ((p_str_t = static_cast<T *>(malloc(sizeof(T) * (size_str) ) ) ) != nullptr) p_str = p_str_t;
             p_str_t = nullptr; assert(p_str != nullptr);                 
}
 
//------------------------------------------------------------------
public:
 
/* Конструктор символы */
 string(const T *pstr) {
            assert(pstr != nullptr);
            if((leng = custom_strnlen<T>(pstr) ) > 0U) { malloc_foo(leng); 
                    custom_strncpy_s<T>(p_str,pstr,leng, size_str);
            }  
 }
 
//------------------------------------------------------------------
 
/* Конструктор по умолчанию */
string() { 
    size_str =  SIZE_STRING ;
    p_str = static_cast<T *> (calloc(size_str, sizeof(T) ) ); 
; }
 
//------------------------------------------------------------------
/* Конструктор копирования */
string(const string<T>& s) {    
    leng  = s.leng; realloc_foo(leng);
    custom_strncpy_s<T>(p_str, s.p_str, leng, size_str); 
}
 
 
//------------------------------------------------------------------
/* Конструктор перемещения */
string(string<T> &&moved) noexcept 
{  
            size_str        = moved.size_str;          
            p_str           = moved.p_str;   
            leng            = moved.leng;
            moved.p_str     = nullptr;
            moved.size_str  = moved.leng = 0U; 
}
 
//------------------------------------------------------------------
~string() noexcept {
            if(p_str != nullptr)    free(p_str);    
            p_str = nullptr;        size_str = leng = 0U;  
}
 
//------------------------------------------------------------------
size_t length() const { return leng ; }
 
//------------------------------------------------------------------
size_t string_size() const  {   
            return (p_str == nullptr) ? 0U : ((leng +  1) * sizeof(T));    
}
 
//------------------------------------------------------------------
/* Добавляем строку с реолакацией памяти */
 
void add(const T *p_str_in)
{  
    assert(p_str_in != nullptr || p_str != nullptr); size_t l = 0;   
     if ((l = custom_strnlen<T>(p_str_in)) != 0U) { 
            realloc_foo(leng + l); 
            custom_strncat_s<T>(p_str, leng, p_str_in, l, size_str); leng += l;          
        }    
}
//------------------------------------------------------------------
void add(const string<T>& s)
{     
    size_t l = s.leng ; realloc_foo(leng + l); 
    custom_strncat_s<T>(p_str, leng, s.p_str, l, size_str); leng += l; 
}
//------------------------------------------------------------------
const T* c_str() const { return (p_str != nullptr) ? p_str : 0; }
 
//------------------------------------------------------------------
void clear() { 
    *p_str = (T)'\0'; leng = custom_strnlen<T>(p_str); 
    size_str =  SIZE_STRING ;
    realloc_foo(size_str - 1); }
 
//------------------------------------------------------------------
string<T> &operator += (string<T> const &s )    { add(s); return  *this; }
 
string<T> &operator += (const T *str )      { add(str); return  *this; }
 
//------------------------------------------------------------------
const string<T> &operator = (const string<T> & s) {            
                string<T> tmp(s); swap (*this, tmp); 
                return *this;
}
//------------------------------------------------------------------
string<T> &operator = (string<T>&& moved)   noexcept    { swap (*this, moved); return *this; }
 
//------------------------------------------------------------------ 
            T &operator[]   (const size_t index)        { assert(index < leng); return p_str[index]; }
 const      T &operator[]   (const size_t index) const  { assert(index < leng); return p_str[index]; }
            string<T> *operator->   ()                  { return this; }
 
//------------------------------------------------------------------ 
 friend std::wostream &operator << (std::wostream &ostr,    string<T> const &str)   { ostr << str.c_str(); return ostr;}
 friend std::wistream &operator >> (std::wistream &in,  string<T>           &str)   {}
 
 friend std::ostream &operator << (std::ostream &ostr,  string<T> const &str)       { ostr << str.c_str(); return ostr;}
 friend std::istream &operator >> (std::istream &in,    string<T>           &str)   {}
 
 friend  const string<T> operator + (const string<T> &l, const string<T> &r)        {  return string<T>(l) += r;} 
 //------------------------------------------------------------------ 
 friend void swap (string<T> &l, string<T> &r)
    { 
        std::swap (l.p_str ,    r.p_str);
        std::swap (l.leng ,     r.leng);
        std::swap (l.size_str , r.size_str);
    }
 //------------------------------------------------------------------ 
friend bool operator <  (const string<T> &l, const string<T> &r) noexcept {/**/}
 
friend bool operator >  (const string<T> &l, const string<T> &r) noexcept {/**/}
 
friend bool operator == (const string<T> &l, const string<T> &r) noexcept {/**/}
 
 
//------------------------------------------------------------------ 
#ifdef SIZE
#undef SIZE
#endif
/* Конец string  */
};
 
//------------------------------------------------------------------
/* Конец области str:: */
};

Добавлено через 5 минут
Так я тестировал на вылеты, вроде норм

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 for(size_t i = 0; i< 1000;i++)
 {
        str::string str(L"Привет ");
        str::string st(L" ghbdtn ");
        str::string str1(L" Вася Пупкин ");
        str::string str2(L" Мир !");
        str::string str3 = std::move(st);
 
        str += str2; 
        str = str1  + str + str2  + L" Не Может" + L" Может";
         
        std::wcout << __FUNCTION__<< L" Итоговая строка : \t" << str << L" Length :" << str.length() << std::endl;
        str = str1; str1 += str2;
        std::wcout << __FUNCTION__<< L" Итоговая строка : \t" << str << L" Length :" << str.length() << std::endl; 
        str1 = str; str->clear();
        std::wcout << __FUNCTION__<<L" Итоговая строка : \t" <<str1 << L" Length :" << str1.length() << std::endl; 
 
}

@sdf45 · 21.01.2024, 17:56

https://github.com/JeremyDsilva/String
бегло пролистал, по-моему очень похоже на то, что ты пишешь. (но не шаблонах)
там в срр есть оператор >> в самом конце

@Signum7 · 21.01.2024, 21:21 **[ТС]**

Сообщение от sdf45

https://github.com/JeremyDsilva/String
бегло пролистал, по-моему очень похоже на то, что ты пишешь. (но не шаблонах)
там в срр есть оператор >> в самом конце

ого там классище идею оператора >> посмотрел там, еще вариант конструктора там еще один себе такой же сделаю, передавать строку уже с запрашиваем размером буфера идея интересная.

Добавлено через 1 час 21 минуту
нашел такую конструкцию скажите ее можно использовать? либо есть альтернативы которые можете рекомендовать?

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
std::wstring str2wstr(std::string_view str)
{
    int size_needed = MultiByteToWideChar(CP_UTF8, 0, &str[0], (int)str.size(), nullptr, 0);
    std::wstring wstrTo(size_needed, 0);
    MultiByteToWideChar(CP_UTF8, 0, &str[0], (int)str.size(), &wstrTo[0], size_needed);
    return wstrTo;
}
std::string wstr2str(const std::wstring& wstr)
{
    int size_needed = WideCharToMultiByte(CP_ACP, 0, wstr.c_str(), int(wstr.length() + 1), 0, 0, 0, 0);
    std::string strTo(size_needed, 0);
    WideCharToMultiByte(CP_ACP, 0, wstr.c_str(), int(wstr.length() + 1), &strTo[0], size_needed, 0, 0);
    return strTo;
}

Не совсем подходит просит #include <windows.h>

@Signum7 · 22.01.2024, 17:05 **[ТС]**

Свой шаблонный класс string для char wchar_t, оптимизация Продолжение...

Новые блоги и статьи Все статьи Все блоги /
Скрипты Tampermonkey для CyberForum, ChatGPT, Claude и пр. Jin X 06.09.2026 Скрипты Tampermonkey для CyberForum, ChatGPT, Claude и пр. Работая с форумом и нейросетями в браузере часто хочется что-то подкорректировать или добавить какого-то функционала. Ниже прикреплён. . .	Программа опроса у.з. расходомера SLS-720F Argus19 02.09.2026 Программа опроса у. з. расходомера SLS-720F Программа опрашивает один раз в минуту три ультразвуковых расходомера SLS-720F через интерфейс RS-485 по протоколу Modbus RTU. Опрашиваются регистры. . .	Hyper-V: Компьютер должен поддерживать доверенный платформенный модуль 2.0. Maks 31.08.2026 При установке Windows 11 на виртуальную машину Hyper-V 2-го поколения вылезла такая ошибка: Решение: в параметрах виртуальной машины, в разделе "Безопасность" (Security) активировать флаг. . .	Архитектура биовида Стива в Майнкрафте: Зачем бонобо кубический каннибализм anaschu 30.08.2026 Кубический Вагинокапитализм в Minecraft: Математический инвариант ОДУ и рок Стивов-бонобо Главная задача разработанной «Модели Всего» — наглядно продемонстрировать наличие системной «судьбы». . .
Оттачиваю умение писать js программы. russiannick 30.08.2026 Проектом выходного дня стало написание Книги шифров Виженера. Итогом стала версия 200, синий туман. Синий туман назван так, потому что замораживает текст под собой. Нажатие синих кнопок управляют. . .	мат медиц модель 30. презентация проекта anaschu 27.08.2026 хоп хоп хоп хидахоп, а я кладую))	Как у меня протекала болезнь zorxor 27.08.2026 Здравствуйте, друзья! Эта запись блога предназначена именно для вас - для моих дорогих друзей, которые знали меня лично. Чтобы ответить на вопрос - а что же со мной произошло на самом деле? Я учился. . .	Нашел вот забавное видео о измерениях. Лучшее что я видел на эту тему kumehtar 26.08.2026 ILETXiw9bMQ Основная суть и тезисы по измерениям: 0D (Нулевое измерение): точка, не имеющая длины, ширины, высоты или объема. Объект не может перемещаться в 0D. 1D (Первое измерение):. . .

@SmallEvil 4086 / 2975 / 813 Регистрация: 29.06.2020 Сообщений: 11,000
	19.01.2024, 18:09
	Signum7, static_assert плюс is_same 1

@DrOffset 19506 / 10109 / 2463 Регистрация: 30.01.2014 Сообщений: 17,833
	19.01.2024, 19:52
	Signum7, через задницу и само без усилий получится, а специально лучше так не делать 1

@SmallEvil 4086 / 2975 / 813 Регистрация: 29.06.2020 Сообщений: 11,000
	20.01.2024, 20:37
	Signum7, static_assert доступен с C++11. C++ - статически типизированный ЯП. То есть, ошибка будет обнаружена на этапе компиляции, с assert , только в режиме выполнения и только в отладочном режиме, в релизе его не будет. Ну а requiers, да с 20, приведен как возможность современног C++. Вопрос нужен ли вам вообще С++? 0

@sdf45 Покинул чат. 1133 / 728 / 195 Регистрация: 30.03.2021 Сообщений: 2,379
	21.01.2024, 17:56
	https://github.com/JeremyDsilva/String бегло пролистал, по-моему очень похоже на то, что ты пишешь. (но не шаблонах) там в срр есть оператор >> в самом конце 0

@Signum7 1 / 1 / 0 Регистрация: 30.03.2017 Сообщений: 141
	22.01.2024, 17:05 [ТС]
	Свой шаблонный класс string для char wchar_t, оптимизация Продолжение... 0