A>#include <string.h>
A>int main (){
A>  const char* s1="aaa";
A>  const char* s2="aaaaaaaaaa";
A>  int i1=strlen(s1);//i1=3
A>  s1=s2;// :)
A>  int i2=strlen(s1);//i2=10 :)
A>}

A>кто-нибудь свободо применить const_cast и все испортить

Помните, как в C устроены строки: они представляют собой последовательность байтов, и последний байт всегда содержит особое значение 0. Это порождает два очевидных следствия:

1.. Единственый способ определить, где строка кончается (то есть узнать её длину) — это пройти по ней в поисках нулевого байта в самом конце.
2.. Строка не может содержать нулевые байты. Так что хранить произвольные двоичные данные вроде картинки в формате JPEG в строке нельзя.
Почему строки в языке C так работают? А потому что микропроцессор PDP-7, на котором разрабатывались UNIX и C, имел такой строковый тип ASCIZ. ASCIZ означало "ASCII с нулём (zero) на конце."

Неужели это единственный способ хранить строки? Конечно нет, более того, это наихудший способ хранить строки. Для всех нетривиальных программ, API, операционных систем, библиотек классов следует избегать использования ASCIZ строк, как чумы...

  языки: c++
  бибилотеки: stl

  языки: c++ (в т.ч. stl)

SetWindowText(hwnd, "Новый заголовок окна");

Исторически символ занимает 1 байт, в этом случае он имеет тип char.

В свою очередь многобайтные кодировки можно разделить на кодировки с фиксированным количеством байтов — каждому символу соответствует одинаковое количество байтов, и «плавающие», в которых один символ может представляться разным количеством байтов в зависимости от его содержимого. К первым относятся кодировки типа Unicode, в которой каждый символ представлен двумя байтами, ко вторым — UTF-8 и др. Плавающие кодировки — отдельная тема, языки С/С++ не предлагают для них никакой поддержки.

В С/С++ существует специальный тип для многобайтных символов — wchar_t

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

Напомню, что c массивом элементов типа char связан указатель на char

wchar_t sym;
sym=L'ab';

wchar_t sym;
sym='ab';

wchar_t sym;
sym=L'a';

Существует специальный формат для записи символьных литералов – слеш, за которым идет код символа

Применение же этих операций к строкам либо вообще запрещено

Снизить риск такого развития событий способна функция

char* strncpy(char* dest, const char* src, size_t count)

Последний параметр – максимальное количество копируемых символов. Таким образом, передавая туда размер приемника, вы гарантируете, что функция никогда не выйдет за пределы выделенной памяти. Однако помните, что если исходная строка будет скопирована не полностью, нуль-терминатор не появится в результирующей строке. Его придется записать самостоятельно.
ПРЕДУПРЕЖДЕНИЕ
Никогда не забывайте контролировать используемую память!

for (i=0;i<strlen(str);i++) {
    // работа со строкой, не изменяющая ее длину
}

for (unsigned int i = 0, len = strlen(str); i < len; i++) {
    // работа со строкой, не изменяющая ее длину
}

Зачастую требуется преобразовать число в строку и наоборот. Есть несколько способов сделать это.
Во-первых, такие преобразования совсем несложно делать самостоятельно. Оставляю это в качестве домашнего задания

Эти функции очень похожи на printf и scanf, за исключением того, что они работают не с консолью, а со строковым буфером. Для дополнительной информации об этих функциях см. документацию.

1.7 The fundamental storage unit in the C++ memory model is the byte.
A byte is at least large enough to contain any member of the basic execution
character set and is composed of a contiguous sequence of bits, the number
of which is implementation-defined.

3.9.1 Objects declared as characters (char) shall be large enough to store
any member of the implementation’s basic character set. <...> A char, a signed
char, and an unsigned char occupy the same amount of storage and have the same
alignment requirements (3.9); that is, they have the same object representation.
For character types, all bits of the object representation participate in
the value representation. For unsigned character types, all possible bit patterns
of the value representation represent numbers.

5.3.3 The sizeof operator yields the number of bytes in the object
representation of its operand. <...> sizeof(char), sizeof(signed char) and
sizeof(unsigned char) are 1 <...>

3.9.1/5 Type wchar_t is a distinct type <...>

2.13.2
1 <...> An ordinary character literal that contains more than one c-char
is a multicharacter literal. A multicharacterliteral has type int and
implementation-defined value.
1 <...> The value of a wide-character literal containing multiple c-chars
is implementation-defined.

the number of which is implementation-defined.

Исторически символ занимает 1 байт, в этом случае он имеет тип char. При этом существуют и другие кодировки, в которых символ представляется, например, двумя байтами.

ПК>массив не бывает (указатели/ссылки на массив — другое дело). Но, по-моему, именно это и сказано в статье

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

такой подход не работает при использовании указателей, размер которых не зависит от длины последовательности, на которую они указывают.

ПК>По-моему, ты преувеличиваешь. Явные ляпы я вижу только в твоих замечаниях

//
#include <stdlib.h>
//
int main(int argc, char * argv[])
{
    wchar_t sym = L'ab'; 
    return 0;
}

test.cpp(6) : warning C4066: characters beyond first in wide-character constant ignored

ПК>Статья, как статья Есть и хуже, есть и лучше.

ПК>В данном случае, скорее, лени

A>Что значит связан? Леночкой Гименея?

Символьные литералы из расширенного набора записываются в виде L'ab', при этом количество символов между одиночными кавычками и их значение зависят от реализации и соответствуют типу wchar_t.

A>for (unsigned int i = 0, len = strlen(str); i < len; i++) {
A>    // работа со строкой, не изменяющая ее длину
A>}  
A>

A>Ага Очень не сложно строку вида "1,23456-E37" преобразовать в число. Пустяки собственно.

V>Ну, тут Павел по большей части ответил — но я, как автор, должен сам реагировать .

Surrogates
There is a need to support more characters than the 65,536 that fit in the 16-bit Unicode code space. For example, the Chinese speaking community alone uses over 55,000 characters. To answer this need, the Unicode Standard defines surrogates. A surrogate or surrogate pair is a pair of 16-bit Unicode code values that represent a single character. The first (high) surrogate is a 16-bit code value in the range U+D800 to U+DBFF. The second (low) surrogate is a 16-bit code value in the range U+DC00 to U+DFFF. Using surrogates, Unicode can support over one million characters. For more details about surrogates, refer to The Unicode Standard, version 2.0.

Windows 2000 introduces support for basic input, output, and simple sorting of surrogates. However, not all system components are surrogate compatible. Also, surrogates are not supported in Windows 95/98/Me.

void f(char *);
char str[] = "text";
f(str); // Если бы преобразования не было, пришлось бы писать f(&str[0]);

A>>for (unsigned int i = 0, len = strlen(str); i < len; i++)

V>Вопрос не ко мне — я отвечать не буду.

Предполагается, что читателю знакомы следующие особенности
связи между массивами и указателями:

• массив можно привести к указателю на его первый элемент, что неявно
  происходит при передаче массивов в функции, ожидающие указатели
  информация о размере массива переданного таким образом в функцию теряется
  
• в С не существует способа передать массив по значению с сохранением
  его размера
  
• указателя на первый элемент массива достаточно для работы со всем массивом,
  при условии что нам известна его длина.

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

Применение же этих операций к строкам либо вообще запрещено, либо, что еще хуже, их результат в большинстве случаев далек от ожидаемого.

char* s="Hell";
s+='o';

A>>>for (unsigned int i = 0, len = strlen(str); i < len; i++)
A>

// работа со строкой, не изменяющая ее длину