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

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

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

Доброго времени суток.
Создал свой класс string. Цель создания своего класса строк - это скорость работы со строками и второе в образовательных целях. Если реализация получится удачной сделаю библиотеку для личного использования. new и delete решил не использовать, просьба не рекомендовать их. Представленный вариант пока в разработке, но тем не менее работает. Не хочу получить UB и пр. Просьба просмотреть и по возможности проверить. Жду ваших рекомендаций.

Кастомные функции для строк char wchar_t используются внутри класса :

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
#include <iostream>
 
#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 len_max = 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 && len_max--) 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;
}

Собственно мой класс строк:

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
/* Класс 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:
 
        size_t  leng{0U};           /* Количество символов в строке */
        size_t  size_str{0U};       /* Размер выделенной памяти для строки */     
        T       *p_str{nullptr};    /* Строка */
                
//------------------------------------------------------------------
void realloc_foo(size_t len, bool len_contr = true)
{
        T *p_str_t = nullptr; if ((len + 1) == size_str)return;
        /* Контроль минимального размера буфера */
        if (len_contr)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);                 
}
//------------------------------------------------------------------
void calloc_foo(size_t len = SIZE_STRING)
{   if(len > 0) size_str = len;
        T *p_str_t = nullptr;
        if ((p_str_t = static_cast<T *>(calloc(size_str, sizeof(T) ) ) ) != 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(const T *pstr, size_t len) {
            assert(pstr != nullptr);
            if(len  > 0U) { leng = len; malloc_foo(leng);               
                    custom_strncpy_s<T>(p_str, pstr, leng, size_str);
            }  
 }
 
/* Конструктор копирования */
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() {calloc_foo();}
 
~string() noexcept {
            if(p_str != nullptr)    free(p_str);    
            p_str = nullptr;        size_str = leng = 0U;  
}
/* Работа с размером.. */
//------------------------------------------------------------------
bool    empty()         const { assert(p_str != nullptr); return leng ? false : true;}
size_t  length()        const { assert(p_str != nullptr); return leng; }
//size_t    mem_buff()      const { return size_str; } /* Для тест памяти */
size_t  string_size()   const { assert(p_str != nullptr); return ((leng +  1) * sizeof(T)); }
//------------------------------------------------------------------
 
//------------------------------------------------------------------
/* Изменит размер выделенной памяти. Возможно линковать последов, можно делать цепочку вида: s.resize().add("52").c_str(); 
*   возможны нежелательные комбинации цепочек
*/
string<T>& resize(size_t n = SIZE_STRING)
{   assert(p_str != nullptr);
    if(n > 0)realloc_foo(n, false);
    return *this;
}
 
//------------------------------------------------------------------
/* Добавляем строку с реолакацией памяти, можно делать цепочку s.add("1").add("2").add("3").add("4").c_str(); */
 
string<T>& add(const T *p_str_in)
{  
    assert(p_str_in != nullptr || p_str != nullptr); size_t len = 0;   
     if ((len = custom_strnlen<T>(p_str_in)) != 0U) { 
            realloc_foo(leng + len); 
            custom_strncat_s<T>(p_str, leng, p_str_in, len, size_str); leng += len;          
        } return *this;   
 
}
string<T>& add(const T *p_str_in, size_t len)
{  
    assert(p_str_in != nullptr || p_str != nullptr); 
    if (len > 0)
    {
        realloc_foo(leng + len);
        custom_strncat_s<T>(p_str, leng,  p_str_in, len, size_str); leng += len; 
    }return *this;
}
 
string<T>& add(const string<T>& s)
{     
    add(s.p_str, s.leng); return *this;
}
 
//------------------------------------------------------------------
/* Элементный доступ */
 
const   T & at(size_t i)    const   { assert(p_str != nullptr); return operator[](i);}
        T & at(size_t i)            { assert(p_str != nullptr); return operator[](i);}
const   T & front()         const   { assert(p_str != nullptr); return operator[](0);}
        T & front()                 { assert(p_str != nullptr); return operator[](0);}
const   T & back()          const   { assert(p_str != nullptr); return operator[](leng - 1);}
        T & back()                  { assert(p_str != nullptr); return operator[](leng - 1);}
 
//------------------------------------------------------------------
/* Прочее.. */
//------------------------------------------------------------------
#pragma warning(push)
#pragma warning(disable:6276)
const T* c_str() const { return (p_str != nullptr) ? p_str : (T*)'/0'; }
 
//------------------------------------------------------------------
/* Возможно линковать последов. s.clear().add("1").add("2").add("3").add("4").c_str(); */
string<T>&  clear() {   
    size_str =  SIZE_STRING ;
    realloc_foo(size_str - 1); 
    *p_str = (T)'\0'; leng = 0;
    return *this;
}
#pragma warning(pop)
 
/* Операторы доступа */
//------------------------------------------------------------------
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 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);
    }
//------------------------------------------------------------------ 
template<class T_, class T>friend T_ &operator << (T_ &ostr,    string<T> const &str);
 
template<class T_, class T>friend T_ &operator >> (T_ &in,  string<T> &str);
 
 friend  const string<T> operator + (const string<T> &l, const string<T> &r)        {return string<T>(l) += r;} 
 
 //------------------------------------------------------------------ 
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  */
};
 
    template<class T_ = std::ostream, class T > 
inline T_ &  operator << (T_ & ostr, str::string<T> const & str){ostr << str.c_str(); return ostr;}
 
 
    template<class T_ = std::istream, class T>
inline T_ & operator >> (T_ & in, str::string<T>  &str)
{
         /* test  >> test!! */
        str.clear();        
        T ch[1]{}; 
        auto c = -1;
    do {
        c = in.get();
        if (c == -1)break;
        *ch = static_cast<T>(c);
        str.add(ch, 1);
    } while (true);    
    return in;
}
 
 
 
//------------------------------------------------------------------
/* Конец области str:: */
};

где-то:

C++
1
2
str::string str(L"Привет ");
        str::string str2(L" Мир !");

@Signum7 · 22.01.2024, 16:57 **[ТС]**

тест чтения из файла

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Если мы не можем открыть этот файл для чтения его содержимого,
if (!inf)
{
    // то выводим следующее сообщение об ошибке и выполняем функцию exit()
    std::cerr << "Uh oh, SomeText.txt could not be opened for reading!" << std::endl;
    system("pause");
    exit(1);
}
 
// Пока есть данные, которые мы можем прочитать,
while (inf)
{
    // то перемещаем эти данные в строку, которую затем выводим на экран
    str::string strInput;
    inf >> strInput;
    std::cout << strInput << std::endl;
}
 
system("pause");
exit(0);

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

тест создания строк

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
        str::string str4(" Мир !");
        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" :" << str.back() << L" :" << str.front() << std::endl;
        str = str1; str1 += str2;
        std::wcout << __FUNCTION__<< L" Итоговая строка : \t" << str << L" Length :" << str.length() << std::endl; 
        str1 = str; str4->clear();

вывод в консоль:

Алексей1153 · 22.01.2024, 18:34

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

assert((destination != nullptr) || (strc != nullptr));

наверное &&
->

C++
1
assert(destination && strc);

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

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

while (size-- && (*destination++ = *strc++));

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

*ptr++ = *strc++;

зачем лепить такое нечитабельное месиво? Бумагу экономим?

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

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

while ( *str1 && *str2 && *str1 == *str2 ) ++str1, ++str2;

выделенное красным - вроде лишняя проверка

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

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

/* Конструктор по умолчанию */
string() {calloc_foo();}

->

C++
1
string()noexcept=default;

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

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

~string() noexcept {
if(p_str != nullptr) free(p_str);
p_str = nullptr; size_str = leng = 0U;
}

->

C++
1
~string() noexcept { free(p_str); }

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

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

void realloc_foo(size_t len, bool len_contr = true)
{
T *p_str_t = nullptr; if ((len + 1) == size_str)return;
/* Контроль минимального размера буфера */
if (len_contr)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);
}

длина перезаписывается не глядя, а потом realloc раз - вернул 0. Красота

и зачем нужно делать p_str_t = nullptr в конце?

@Signum7 · 22.01.2024, 20:04 **[ТС]**

Сообщение от Алексей1153

длина перезаписывается не глядя, а потом realloc раз - вернул 0. Красота

На самом деле я пока не знаю, что точно мне делать в случае не выделения памяти, этот вопрос пока открыт.

Алексей1153 · 23.01.2024, 08:30

Signum7, по меньшей мере - не менять состояние класса

@Signum7 · 23.01.2024, 19:14 **[ТС]**

Сделал такой вариант перегрузки оператора >> подскажите на сколько оно правильно сделано (файл читает правильно)

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
    template<class T_ = std::istream, class T>
inline T_ & operator >> (T_ & in, str::string<T>  &str)
{
         /* test  >> test!! */
    typedef std::char_traits<T> Traits;
    const auto eof = Traits::eof(); 
    T ch_buf[1]{}; auto c = eof;
    size_t max_size = TRUNCATE;
 
    str.clear();        
    do {
        c = in.get();
        if (Traits::eq_int_type(c, eof))break;
        *ch_buf = Traits::to_char_type(c);
        str.add(ch_buf, 1);
    } while (max_size--);    
    return in;
}

@DrOffset · 23.01.2024, 22:58

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

C++
1
2
3
4
5
6
7
8
9
template<class T_ = std::istream, class T>
inline T_ & operator >> (T_ & in, str::string<T> &str)
{
    /* test  >> test!! */
    typedef std::char_traits<T> Traits;
 
 .
 .
 .

Как минимум:

C++
1
2
3
4
5
6
7
8
template <typename CharT, typename Traits>
std::basic_istream<CharT, Traits>& operator>>(std::basic_istream<CharT, Traits>& in, str::string<CharT>& str)
{
    // typedef std::char_traits<T> Traits; это не нужно, Traits берется из потока.
 
 .
 .
 .

@Signum7 · 24.01.2024, 00:33 **[ТС]**

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

Как минимум:

C++
1
2
3
4
5
6
7
8
template <typename CharT, typename Traits>
std::basic_istream<CharT, Traits>& operator>>(std::basic_istream<CharT, Traits>& in, str::string<CharT>& str)
{
    // typedef std::char_traits<T> Traits; это не нужно, Traits берется из потока.
 
 .
 .
 .

Благодарю за подсказку, но у меня выводит пред моим текстом какую-то служебную информацию вот:
i>? // char_traits_compare.cpp
// compile with: /EHsc

Добавлено через 6 минут
Это если выводить текст в режиме UTF8 c BOM я так понял i>? это bom так как если текст без bom этого нет как сделать чтобы такая информация игнорировалась автоматически?

@DrOffset · 24.01.2024, 00:40

Signum7, ручками отрезать эти байты. В текстовом потоке им нечего делать.
Текстовый поток ориентируется на кодировку локали.

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

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

i>? это bom

Честно говоря сомневаюсь, что это BOM.
Покажите числовые значения этих байт.
В UTF-8 BOM должны быть EF BB BF

@Signum7 · 24.01.2024, 00:47 **[ТС]**

поставил .imbue(std::locale("ru_RU.utf8")); эти символы исчезли но перед текстом появился ? знак странно. какой-то мусор

@DrOffset · 24.01.2024, 00:56

Signum7, весь код нужен.

И имейте в виду, что ваш оператор >> ведет себя нестандартно. Стандартная реализация читает текст до первого пробельного символа, или до конца файла, если такого символа нет.
А то, что вы сделали, больше похожде на медленный read.
К проблеме это не относится, это ремарка по поводу

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

насколько оно правильно

@Signum7 · 24.01.2024, 01:01 **[ТС]**

я так полагаю нужно считать три первых символа и если они бом то их проигнорировать у себя в методе , я верно понял ?

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

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

И имейте в виду, что ваш оператор >> ведет себя нестандартно. Стандартная реализация читает текст до первого пробельного символа, или до конца файла, если такого символа нет.
А то, что вы сделали, больше похожде на медленный read.
К проблеме это не относится, это ремарка по поводу

я так сделал из расчета чтения файла за один заход, но действительно чтение происходит довольно медленно.

@DrOffset · 24.01.2024, 01:06

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

считать три первых символа и если они бом то их проигнорировать у себя в методе , я верно понял ?

Верно.
Правда вы прибьете тогда кодировку гвоздями к реализации метода.
Каноничнее было бы скипать их в своей фасетке для utf-8.

См, например, упразденную ныне (но от этого ничуть не менее полезную для образования) реализацию codecvt_utf8:
https://en.cppreference.com/w/... decvt_mode
https://en.cppreference.com/w/... decvt_utf8

@Signum7 · 24.01.2024, 17:38 **[ТС]**

Такой вариант работает для чтения файла целиком, подскажите как мне его переписать для чтения по стандарту для чтения пословно. Буду благодарен если покажите код, а то что-то я совсем туплю. Благодарю за помощь.

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
template <typename CharT = char, typename Traits>
inline std::basic_istream<CharT, Traits>& operator>>(std::basic_istream<CharT, Traits>& in, str::string<CharT>& str)
 
{
    static constexpr auto BUF = 260U;
    constexpr auto eof = Traits::eof();      
    auto c = eof; 
    
    size_t max_size = TRUNCATE;
    CharT ch_buf[BUF]{};
    
 
    in.seekg (0, in.end);
    size_t lengths = in.tellg();
    in.seekg (0, in.beg);
    str.resize(lengths); 
    
    do {c = in.get();
        
        if (Traits::eq_int_type(c, eof))break;
        *ch_buf = Traits::to_char_type(c);
        str.add(ch_buf, 1); 
    } while ( max_size--);
    return in;
}

@DrOffset · 24.01.2024, 22:36

Signum7, я же показывал ранее пример.

@Signum7 · 24.01.2024, 22:40 **[ТС]**

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

Signum7, я же показывал ранее пример.

Вы имеете в виду это

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

Стандартная реализация читает текст до первого пробельного символа, или до конца файла, если такого символа нет.

тоесть поставить проверку на пробел и конец строки и все?

@DrOffset · 24.01.2024, 22:56

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

Вы имеете в виду это

Я имею в виду пост №71 в вашей предыдущей теме.

@Signum7 · 25.01.2024, 00:33 **[ТС]**

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

Я имею в виду пост №71 в вашей предыдущей теме.

у меня не работает похожая реализация зацикливается на первой строчке

@DrOffset · 25.01.2024, 00:41

Signum7,
Вообще работает: https://wandbox.org/permlink/K81jM2q8UBMWeKoh

Хотя это особо не важно. Представьте, что это псевдокод и берите идеи.

Новые блоги и статьи Все статьи Все блоги /
PhpStorm 2025.3: WSL Terminal всегда стартует в ~ and_y87 14.12.2025 PhpStorm 2025. 3: WSL Terminal всегда стартует в ~ (home), игнорируя директорию проекта Симптом: После обновления до PhpStorm 2025. 3 встроенный терминал WSL открывается в домашней директории. . .	Access VikBal 11.12.2025 Помогите пожалуйста !! Как объединить 2 одинаковые БД Access с разными данными.	Новый ноутбук volvo 07.12.2025 Всем привет. По скидке в "черную пятницу" взял себе новый ноутбук Lenovo ThinkBook 16 G7 на Амазоне: Ryzen 5 7533HS 64 Gb DDR5 1Tb NVMe 16" Full HD Display Win11 Pro	Музыка, написанная Искусственным Интеллектом volvo 04.12.2025 Всем привет. Некоторое время назад меня заинтересовало, что уже умеет ИИ в плане написания музыки для песен, и, собственно, исполнения этих самых песен. Стихов у нас много, уже вышли 4 книги, еще 3. . .	От async/await к виртуальным потокам в Python IndentationError 23.11.2025 Армин Ронахер поставил под сомнение async/ await. Создатель Flask заявляет: цветные функции - провал, виртуальные потоки - решение. Не threading-динозавры, а новое поколение лёгких потоков. Откат?. . .
Поиск "дружественных имён" СОМ портов Argus19 22.11.2025 Поиск "дружественных имён" СОМ портов На странице: https:/ / norseev. ru/ 2018/ 01/ 04/ comportlist_windows/ нашёл схожую тему. Там приведён код на С++, который показывает только имена СОМ портов, типа,. . .	Сколько Государство потратило денег на меня, обеспечивая инсулином. Programma_Boinc 20.11.2025 Сколько Государство потратило денег на меня, обеспечивая инсулином. Вот решила сделать интересный приблизительный подсчет, сколько государство потратило на меня денег на покупку инсулинов. . . .	Ломающие изменения в C#.NStar Alpha Etyuhibosecyu 20.11.2025 Уже можно не только тестировать, но и пользоваться C#. NStar - писать оконные приложения, содержащие надписи, кнопки, текстовые поля и даже изображения, например, моя игра "Три в ряд" написана на этом. . .	Мысли в слух kumehtar 18.11.2025 Кстати, совсем недавно имел разговор на тему медитаций с людьми. И обнаружил, что они вообще не понимают что такое медитация и зачем она нужна. Самые базовые вещи. Для них это - когда просто люди. . .	Создание Single Page Application на фреймах krapotkin 16.11.2025 Статья исключительно для начинающих. Подходы оригинальностью не блещут. В век Веб все очень привыкли к дизайну Single-Page-Application . Быстренько разберем подход "на фреймах". Мы делаем одну. . .

Алексей1153 фрилансер 6442 / 5636 / 1127 Регистрация: 11.10.2019 Сообщений: 14,983
	23.01.2024, 08:30
	Signum7, по меньшей мере - не менять состояние класса 0

@Signum7 1 / 1 / 0 Регистрация: 30.03.2017 Сообщений: 133
	24.01.2024, 00:47 [ТС]
	поставил .imbue(std::locale("ru_RU.utf8")); эти символы исчезли но перед текстом появился ? знак странно. какой-то мусор Миниатюры 0

@DrOffset 19491 / 10097 / 2460 Регистрация: 30.01.2014 Сообщений: 17,805
	24.01.2024, 22:36
	Signum7, я же показывал ранее пример. 0

@DrOffset 19491 / 10097 / 2460 Регистрация: 30.01.2014 Сообщений: 17,805
	25.01.2024, 00:41
	Signum7, Вообще работает: https://wandbox.org/permlink/K81jM2q8UBMWeKoh Хотя это особо не важно. Представьте, что это псевдокод и берите идеи. 1