Очень извеняюсь если тема уже проходила.
Нужно сложыть 2 строки на C. Делаю:

Код

char q;  q="sss"+"ddd";

Пишет
Error: noname01.cpp(8,10):Invalid pointer addition

Что не так?

char q -- символ. ты хочеш две строки сложить в символ?

В параграфе 6.5.6 стандарта C99 сказано, что для сложения необходимо чтобы оба операторы имели арифметический тип, либо один из операторов имел арифметический тип, а другой был указателем.

Другими словами, Си не позволяет складывать указатели, а "sss" и "ddd" и есть указатели на тип char. Значит Си не позволит сложить их. Поэтому возникает error.

Для сложения строк в Си используется в частности функция strcat(3), которая во-первых стандартная, во-вторых рассматривалась в этом же форуме "С/С++ Общие Вопросы", последнее обновление кстати "24.5.2005, 09:31\nАвтор: Peter" и называлось это "Работа с strcat".

Код

string q;  q="sss"+"ddd";

Irokez

Цитата

string q; q="sss"+"ddd";

Не прокатит

Код

string q = "sss";  q +="ddd";

Это сообщение отредактировал(а) bel_nikita - 25.5.2005, 20:41

Цитата(bel_nikita @ 25.5.2005, 20:41)

Не прокатит smile

говорю же, недоучил с++

Код

string q; q=(string)"sss"+"ddd";

Гм.
Вообще-то правильно использовать оператор "+" только в применении к классу CString, так как он там перегружен. А по стандарту:

Код

char* q; strcpy(q,"123"); strcat(q,"456");

Только не забудь:

Код

char* q=new char[256]; //например

Считаю, что каждый СиПлюсПлюснутый должен иметь свой класс работ со строками.

Цитата

Считаю, что каждый СиПлюсПлюснутый должен иметь свой класс работ со строками

Считаю, что что каждый СиПлюсПлюснутый должен использовать std::string - да бы не было недоразумения и велосипедов, и была переносимость кода

Цитата(bel_nikita @ 26.5.2005, 09:11)

да бы не было недоразумения и велосипедов

Если бы небыло "велосипедов", то так же небыло бы компьютера, машин и много других великих открытий человечества. Недоразумение - тоже знание, а точнее опыт!

Это не тот случай. На ошибках нужно учиться, а не повторять каждый раз одни и те же.
И использовать написанное умными людьми. Ну все, ушли в оффтоп, хотя тут и обсуждать нечего

Да, не надо оффтопить плиз А вто если кто статейку напишет по базовым понятиям сравнения и сложения строк. Чтобы даже полный новичёк смог понять (с картинками итд), того лично отблагодарю.

Эти вопросы часто возникают. Много новичков программировали на "простых" языках типа Бэйсика или какого нибудь скриптового языка. Им не там просто понять, что указатель и сам массив вещи немного разные .

Вот можно было бы людей туда перенаправлять.

вот есть статьи о строках и их сравнение, вполне доступные для понимания новичков:
Строки в С и С++
Сравнение std::string без учета регистра

shad0w

сhar g - Один символ! Если хочешь сложить, хотя бы массив выдели.

q="sss"+"ddd"; - строки скалдываются не так , а в цикле


Alastis
А хорошая ссылка, кста

ссылка хорошая, но для новичков ИМХО чуточку слишком много ...
Надо бы на пальцах..

sergej.z Статья уже есть или мне можно приниматься?..

Нет статьи

Не вопрос!..

Типы данных.

Сказанное ниже гарантировано соотносится со спецификациями Си/Си++. Наверняка во многих других языках действуют похожие правила.

1. Простые типы данных.

К простым типам относят: одиночные символы, любые числовые переменные и пр.

Код

char ch;// один 8-битный символ (в разных компиляторах может быть unsigned или signed) unsigned char uch;// гарантированно беззнаковая 8-битная переменная; байт проще говоря signed char sch;// гарантировано знаковая 8-битная переменная; минус один бит на знак int i;// целочисленная переменная со знаком unsigned int ui;// целочисленная переменная без знака float fl;// число с плавающей точкой

2. Сложные типы данных.

К сложным типам данных относят для Си - структуры, объединения и массивы; для Си++ - тоже + классы. Сложные типы можно также назвать составными, т.к. они в конечном итоге всё равно содержат в себе простые (сложный тип = набор простых). Важно понять, что процессор не умеет работать со сложными типами. Он не может понять, что такое std::string или char[10]. Для него это - набор простых типов. Программист так же никогда не работает со сложными типами напрямую - он работает только с указателями на сложные типы. Что это такое разберём дальше.

3. Указатели.

Любой указатель принадлежит простому типу и содержит в себе адрес определённой ячейки памяти. Чаще всего в 32-битных процессорах x86 используют 32-битные же указатели. Проще говоря, в большинстве случаев любой указатель имеет тип unsigned int. Программист работает со сложными объектами только при помощи указателей. Даже когда он видит перед собой объект типом char[10] он должен знать, что это - лишь указатель на область памяти, где находится десять переменных простого типа char. Типы int* и int[] абсолютно идеинтичны - это указатели на массивы памяти. Разница только в одном: один из этих указателей динамический, а другой статический. Что это такое? Проще пояснить примером:

Код

int iArray[10];// Создаётся десять переменных типом int следующих в памяти друг за другом и тут же -  // создаётся константа(!) типом int* - указатель; причём переменной "указатель" тут же автоматически // присваивается значение адреса десяти int-овых переменных - всё в одной строчке! int* pInt;// Создаётся только(!) переменная типом int*; никакого массива мы ещё не получили! pInt = new int[10];// Вот теперь всё в порядке; функция(в Си - оператор) new создаёт десять  // переменных типом int и возвращает адрес на первую из этих переменных, который  // присваивается переменной-указателю pInt

Первый массив называют статическим, второй - динамическим. Соответственно, переменная iArray - статическая, pInt - динамическая. Кстати, если вы напишете вот это:

Код

int* pInt[10];

То вы получите десять переменных-указателей и ни одного массива. Чтобы получать массивы динамическим образом ("на ходу") вам необходимо самостоятельно вызвать оператор new или функцию выделения памяти и после завершения использования - удалить массив вызовом delete или функцией освобождения памяти. Со статическими массивами проще - там компилятор сам решает где взять память и когда её освободить, причём делает и то и другое с необыкновенной быстротой, потому как всё это определяется ещё на моменте компиляции, а не в процессе исполнения. Казалось бы, все преимущества статических переменных на лицо, зачем же использовать динамические? Не торопитесь.

Код

int* i = new int;// Тоже массив, кстати. Правда содержит всего один элемент... // какие-то операции с i delete i;// Освобождаем старый массив (указатель никуда не девается!) i = new int [10];// Создаём новый, значительно больше прежнего int iA[10]; delete iA;// Ошибка! iA = new int[12];// Тоже самое... int nElements = 0; // Вычисление значения nElements int iArray[nElements];// Ошибка! Рамер должен быть константным! int pArray = new int[nElements];// Никаких проблем, всё работает...

Теперь можно привести примеры с извечной проблемой строк, которая проблемой по сути является только для новичков (камень в огород Си-ненавистников).

Код

char* str = "STRING";// Глупо выглядит, но эта строчка - работает! strcpy(str, "А вот эта - нет");

Почему первая строка работает, а вторая - сбоит? Всё просто. "STRING" - константный набор данных. Откройте свою программу любым текстовым редактором - вы там без труда найдёте эту строку. В первой строке вышеприведённого кода происходит присвоение указателю char* str адреса константной области данных, содержащей "STRING". При попытке изменить эту область операционная система даёт нам оплеуху и выкидывает программу из списка процессов. Вот этот код работает:

Код

char* str = "STRING";// Тишина... и мёртвы с косами ходят... char* s = new char[7]; strcpy(s, str);// Ей богу, на воровство похоже!

Лучше такой экзотикой не заниматься, а писать сразу в вызов функции strcpy строку "STRING", потому как никто не гарантирует, что где-нибудь в губине кода не произойдёт следующее:

Код

str[3] = 'O';// Забыли мы где находимся :-)

----------

Думаю достаточно понятно объяснил. Если нет - критикуйте, поправлю. Могу продолжить тему и написать что-нибудь вроде "Трюкачи на Си++", но в принципе, говорят, по этому делу есть множество книг

Это сообщение отредактировал(а) ManiaK - 31.5.2005, 18:58

Несколько ЗУП (замечаний/уточнений/предложений):

1) Про всеми любимый strcat забыл.

2)

Цитата(ManiaK @ 31.5.2005, 18:55)

Проще говоря, в большинстве случаев любой указатель имеет тип unsigned int.

Для блеска: лучше что-нибудь типа "по размеру совпадает с unsigned long" - ибо
1) Сработает и для 64 битных компов тоже, и для 16битного доса с оговоркой, что это FAR указатель.
2) Указатели все же имеют тип указателя.

3)

Цитата(ManiaK @ 31.5.2005, 18:55)

Код int* pInt[10]; То вы получите десять переменных-указателей и ни одного массива.

Не правда. pInt - это как раз массив из десяти указателей. Если бы я был новичком, меня бы это могло спутать: как так, [10] есть, а массива нет? Я б вообще мог решить что TYPE* blahblah[] некорректно, и надо юзать только одно - либо TYPE*=new, либо TYPE[].

4) Опять же, если бы я был новичком в сях, то я считал бы,что первый элемент массива имеет индекс 1, а не 0. То есть я считал бы a[0] бредом(а a[-2] вообще научной фантастикой)


А что есть "трюкачи для С++"? Типа a^=b,b^=a,a^=b? Тогда давай!

Это сообщение отредактировал(а) Mayk - 31.5.2005, 19:44

ManiaK
Продолжать будешь? Как насчет строк в STL, std::string? Вообще хотелось бы прочитать все возможное о строках.
Или хотя бы РАБОТУ со строками, это же лишь введение, показано лишь как правильно объявлять, удалять...

Несколько важных моментов для новичков и тех, кто переходит с Паскаля:

• В паскале строка - массив символов, нулевой элемент массива - длина строки, в С строка - это указатель на первый элемент, ничего больше. Это уже говорилось, но стоит повторить.
  Где же проявляются различия? Почти нигде, обращаться к элементу строки по индексу можно. Но если вы используете scanf...
  

  Код

  int a; float b;       printf("input int a, float b: \n");     scanf("%d%f",&a,&b);

  
  Первый параметр - строка задающая формат вводимых данных, в нашем случае int и float. А затем идет список аргументов, который определяет, куда данные пойдут. Здесь нужно указывать адрес переменных, то есть указатели на них, для это применяется операция разыменования &. Но поскольку строка и так уже адрес (указатель), то никаких амперсандов там не нужно:
  

  Код

  int a; float b; char str[10];       printf("input int a, float b, string str: \n");     scanf("%d%f",&a,&b,str);

• Признак окончания строки - символ '\0'. Также можно вставлять в строки символы '\n' (переход на новую строку) , '\t'(табуляция), '\r' (возврат каретки).
• объявление char str[10] создаст массив из 11 элементов, 0-9 - собственно строка, 10 - символ '\0';
  Как можно объявлять строки?
  

  Код

  char str[] = "string"; char* str = "string"; char str[] = {"string"}; char str[]={'s','t','r','i','n','g','\0'};

Добавлено @ 20:14
И еще. Кавычки
Ух, сколько дельфистов ломают себе голову, почему не работает

Код

char str[]='hello';

Дело в том, что одинарные кавычки применяются только для символов, для строк - двойные.

Это сообщение отредактировал(а) kometa_triatlon - 31.5.2005, 20:08

Mayk за пункт 3 и 4 - спасибо! сейчас поправлю статью. Насчёт "трюкачей" - это например:

Код

template<UInt_t ID> struct Msg { }; void Function100(Msg<100> msg) { } void Function101(Msg<101> msg) { } template<UInt_t ID> UInt_t GetMsgID(void (*pFunc)(Msg<ID>&)) { return ID; } // Где-то в main UInt_t i = GetMsgID(&Function100);// i = 100

Вообщем "подводные камни" на тему типов данных и шаблонов.

kometa_triatlon Напишем! Можно даже нечто вроде урока "пишем свой класс строк" со всеми подробностями. STL - без вопросов!..

Цитата(ManiaK @ 31.5.2005, 22:20)

Вообщем "подводные камни" на тему типов данных и шаблонов.

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

Цитата(ManiaK @ 31.5.2005, 22:20)

Можно даже нечто вроде урока "пишем свой класс строк" со всеми подробностями. STL - без вопросов!..

Вот это, имхо, будет очень хорошое пособие по "классостроению в C++ для начинающих"! Поддерживаю! (к сожалению, только морально, ибо сессия )

Пишем свой класс строк.

0. Объяснительная.

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

1. А что нам, собственно, надо?

Для начала определимся, что должен делать наш класс по определению, без чего он вообще жить не может. Для многих начинающих программистов этот вопрос является едва ли не самым сложным. Вот мой список:

1) Класс должен полностью замещать Си-строку. В идеале, везде, где можно воткнуть char* мы должны воткнуть String, но я по ряду причин отказался от данной технологии и остановился на функциях GetCStr.
2) Присвоение.
3) Конкатенация (сложение).
4) Вставку строк/символов в определённое место.
5) Вырезание отдельных символов/строки.
6) Сравнение.
7) Замена.
8) Поиск строк/символов с заданной позиции.
9) Поиск числа вхождений строк/символов.
10) Преобразование строк в численные типы и обратно.

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

3. Пишем объявление класса.

Мой метод написания классов: пишу сначала объявление (то, что в *.h находится) не вдаваясь ни в какие подробности реализации и только потом берусь за проработку каждой отдельной функции. Этот метод позволяет на первой стадии не отвлекаться на мелочи и "сверху" взглянуть на проблему, уловить некоторые моменты, про которые можно просто забыть.

Так как я использую класс из собственной библиотеки, типы данных у меня объявлены по-своему. Если кому-то не понравится - на то есть операция "Замена" в любом текстовом редакторе. Лично мне кажется, что подобное объявление хоть и приводит к излишей писанине, значительно упрощает чтение программы. Итак, вот список typedef-определений:

Код

// Базовые типы typedef void Void_t; typedef bool Bool_t; typedef char Char_t; typedef unsigned short WChar_t; typedef double Real_t; typedef Char_t* Str_t; typedef WChar_t* WStr_t; typedef signed int Int_t; typedef signed short Short_t; typedef unsigned char Byte_t; typedef unsigned short UShort_t; typedef unsigned short Word_t; typedef unsigned int UInt_t; typedef unsigned int DWord_t; typedef Void_t* VPtr_t;

Как видите, не трудно "угадать" что под чем скрывается даже при первом прочтении.

Только теперь вспомнил: мой класс работает только со строками char*. Но ведь, я думаю, не трудно будет это и самому переделать "по аналогии"?..

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

Код

template<class Type> class QObject// Дурной умный указатель :-) { public:     QObject();     QObject(const Type& Ch);     QObject(const QObject& Obj);     virtual ~QObject();     QObject& operator = (const QObject& Obj);     QObject& operator = (const Type& Obj);     Bool_t operator == (const Type& Obj) const;     Bool_t operator == (const QObject& Obj) const;          UInt_t GetSize(Void_t) const;     Type& GetObject(const UInt_t nInd = 0);     Bool_t IsValid(Void_t) const;     Void_t Empty(Void_t);     Bool_t Alloc(const UInt_t nSize);          VPtr_t operator new (const UInt_t nBytes) ;     VPtr_t operator new [] (const UInt_t nBytes);          Void_t operator delete (VPtr_t pObj);     Void_t operator delete [] (VPtr_t pObj);     Bool_t operator ! () const; protected:     Type*    m_pData;     UInt_t    m_nSize; };

Как видите, всё просто. Аллокатор у меня свой, однако это ни на что не должно влиять. Прошу обратить внимание на все эти "const" разбросаные по всему классу: говоря словами Д. Элджера, подобную технологию надо использовать с полным фанатизмом, либо не использовать вовсе, причём приветствуется первое. Однако это не так просто, особенно когда происходят стыковки со сторонними бибиотеками, где константы не используют - вот тут-то, случается, ночи напролёт боёв с компилятором!..

Теперь декларация класса строки:

Код

class QString : public QObject<Char_t> { public:     // Куча конструкторов     QString();     QString(const QString& Str);     QString(Str_t pCStr);     QString(Str_t pStr, UInt_t nSize);     QString(Char_t Ch, UInt_t nRep = 1);     // Деструктор     virtual ~QString() { }          // Формирование Си-строки     Str_t MakeCStr(Str_t pStr, UInt_t nStart=1, UInt_t nEnd=0) const;     WStr_t MakeCStr(WStr_t pTStr, UInt_t nStart=1,         UInt_t nEnd=0) const;     QString GetPart(UInt_t nStart=1, UInt_t nEnd=0) const;     Void_t GetPart(QString& Str, UInt_t nStart=1, UInt_t nEnd=0) const;     // Добавление     QString& Add(Str_t pCStr);     QString& Add(Str_t pStr, UInt_t nSize);     QString& Add(const QString& Str);     QString& Add(const QString& Str, UInt_t nSize);     QString& Add(Char_t Ch, UInt_t nRep);     // Вставка     QString& Insert(Char_t Ch, UInt_t nPos);     QString& Insert(Str_t pCStr, UInt_t nPos);     QString& Insert(Str_t pStr, UInt_t nSize, UInt_t nPos);     QString& Insert(const QString& Str, UInt_t nPos);          // Удаление     QString& Del(UInt_t nPos);     QString& Del(UInt_t nStart, UInt_t nLast);          // Поиск     UInt_t FindFirst(Char_t Ch, UInt_t nStart=1,         UInt_t nLast=0) const;     UInt_t FindFirst(const QString& Str, UInt_t nStart=1) const;     UInt_t FindFirst(Str_t pCStr, UInt_t nStart=1) const;     UInt_t FindEnd(Char_t Ch, UInt_t nStart=1,         UInt_t nLast=0) const;     UInt_t FindEnd(const QString& Str, UInt_t nStart=1) const;     UInt_t FindEnd(Str_t pCStr, UInt_t nStart=1) const;     UInt_t FindCompute(Char_t Ch, UInt_t nStart=1,          UInt_t nLast=0) const;     UInt_t FindCompute(const QString& Str, UInt_t nStart=1) const;     UInt_t FindCompute(Str_t pCStr, UInt_t nStart=1) const;     // Замена     UInt_t Replace(Str_t pCFnd, Str_t pCRpl,         UInt_t nStart=1, UInt_t nMaxRepl=0);     UInt_t Replace(const QString& Fnd, const QString& Rpl,         UInt_t nStart=1, UInt_t nMaxRepl=0);          Bool_t Compare(Str_t pCStr) const;     Bool_t Compare(const QString& Str) const;          // Операторы прабавления к концу     QString& operator += (Char_t Ch);     QString& operator += (Str_t pCStr);     QString& operator += (const QString& Str);     // Операторы присвоения     QString& operator = (Char_t Ch);     QString& operator = (Str_t pCStr);     QString& operator = (const QString& Str);     // Операторы сравнения     Bool_t    operator == (Char_t Ch) const;     Bool_t    operator == (Str_t pCStr) const;     Bool_t    operator == (const QString& Str) const;     Bool_t    operator != (Char_t Ch) const;     Bool_t    operator != (Str_t pCStr) const;     Bool_t    operator != (const QString& Str) const;          QString operator + (Char_t Ch) const;     QString operator + (Str_t pCStr) const;     QString operator + (const QString& Str) const;     Char_t&    operator [] (UInt_t nPos);     const Char_t&    operator [] (UInt_t nPos) const;          // Нахождение размера строки     static UInt_t StrLen(Str_t pStr); };

У вас в глазах не рябит? Действительно, констант тут немало...
Кстати, если вы уже заметили, этот класс совершенно изолирован и может использоваться сам по себе, без подключения даже стандартных string.h или stdlib.h. Разумеется, это только для заголовочного файла - при реализации всё равно придётся на что-то опираться (хотя бы из соображений эфективности). Вопреки опУпсевшемуся уже оператору приведения к char*, я его не включил в список. Хотя бы уже из соображений безопастности (никто не гарантирует мне, что переданный указатель на m_pData будет использоваться только для чтения). Однако вы можете это сделать сами вставив всего одну строчку в декларацию класса:

Код

operator Str_t (Void_t) { return m_pData; }

Разделю-ка я на два поста статейку... Реализация - в следующем.


Это сообщение отредактировал(а) ManiaK - 31.5.2005, 22:02

Цитата(ManiaK @ 31.5.2005, 23:00)

Код const /* ! */ Char_t&    operator [] (const UInt_t nPos) const;

В глаза бросилось...
И еще - value-типы передавать с модификатором const, имхо, немножко некрасиво... и бессмысленно

Это сообщение отредактировал(а) Void - 31.5.2005, 21:17

Цитата(Void @ 31.5.2005, 21:15)

const /* ! */ Char_t&    operator [] (const UInt_t nPos) const;

Не вижу такого. У меня вот:

Цитата(ManiaK @ 31.5.2005, 21:00)

Char_t&    operator [] (const UInt_t nPos);     Char_t&    operator [] (const UInt_t nPos) const;

Про value-типы скажу ещё.

Цитата(ManiaK @ 31.5.2005, 23:23)

Не вижу такого. У меня вот:

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

Любопытно:) Я раньше на это внимания не обращал, спасибо!:)

Хмм. А в статье нельзя обойти использование наследования?
Это ведь вроде как для новичков? Если бы я опять был новичком, то слова "allocator, QObject<Char_t>, operator" были бы для меня открытыием.
"operator Int_t const ()" я б вообще не понял. Кстати, оно тут вообще надо?

Предположим есть функция myConnect(const QString& host, int port),
а мы напишем myConnect(123, someHost()). QString host получится из конструктора
(кстати, const int в конструкторе - это перебор), someHost() преобразуется в int, а в результате получится совсем не то, что надо. Ну их нафиг эти приведения типов. ИМХО.

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

Чем дальше в лес, тем толще партизаны...
Куда вы залезли? Зачем это тем, кто начинает изучать?
Господи, перегрузка, шаблоны, классы... Да новичок испугается и сразу закроет статью, к тому же не поймет ничего. Так что есть предложение перенести пару этих постов в отдельную тему, например "Нюансы использования строк", "Строки для продвинутых" или что-то такое.
А то тема переросла в что-то несистематическое и непонятное. Как будто выбросили хороший кусок посредине.
И нет самого основного - работы со строками.
По-моему, остается еще нераскрытый вопрос: арифметические операции с указателями в применении к строкам. То есть операции типа str++, (array+4)*...
Void кстати показал хороший пример на эту тему, но раз у него сессия...

Это сообщение отредактировал(а) kometa_triatlon - 31.5.2005, 22:18

Черт, да я давно мечтал написать свой класс строк! Но еще больше мне хочется реализовать класс строковых списков. В vcl имеются очень грамотный и полезный класс TStringList, о мелкософтофский аналог CStringList, я извиняюсь, такое г-но, извращенная муть, что каждый раз при использовании этого д-ма руки чешутся написать свой класс, независящий ни от каких библиотек (кроме библиотеки С++ ес-но ).

А написали-то
Вставлю и я своих пять копеек
ManiaK

Цитата

Код typedef unsigned int DWord_t;

Не есть гуд, так как, к примеру, в Borland 3.1 unsigned int - двухбайтовая величина поэтому DWORD == unsigned long

Цитата

Код UInt_t GetSize(Void_t) const; ... UInt_t    m_nSize;

Вместо UInt_t лучше использовать size_t

З.Ы.: А вообще, новичку нужно использовать std::string дабы не грузить свою голову template'ами и т.д. и т.п. Всему свое время. Когда научится использовать std::string тогда и можно будет поговаривать о изучении и написании своего класса строки.

Цитата

Не есть гуд, так как, к примеру, в Borland 3.1 unsigned int - двухбайтовая величина  поэтому DWORD == unsigned long

Это Борланд не есть гуд
Borland SUXX

Напишите про std::string!!!

Тиха! Пральна kometa_triatlon сказал - этот класс надо в что-нибудь "для средняков". Доделаю уж его сначала (допишу статейку), а потом уж про std::string. Насчёт того, что уже "трюки" различные в книгах описаны: в книгах описано почти всё! было бы желание и время это изучать...

ManiaK
Ну так и все, что ты написал и то, что пишешь, и то, что будешь писать, и то, о чем еще не знаешь - все ведь в книгах описано Но нас хватает только на то, чтобы запустить EDialer и выбрать в букмарках Винград

Цитата(Void @ 31.5.2005, 18:15)

const /* ! */ Char_t&    operator [] (const UInt_t nPos) const;

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

Соглашусь, что здесь const в передаваемом параметре нафиг не нужен.

Не очень догнал красоты наследования класса строки от чего-то. Виртуальный деструктор добавляет таблицу виртуальных методов, а это еще +4 байта к классу. В большинстве случаев это приемлимо, но для класса строки по-моему излишне. Если хочется приладить свое управление памятью, то лучше создать allocator'ы на подобее STL'евских.

Цитата(Mayk @ 31.5.2005, 16:41)

Для блеска: лучше что-нибудь типа "по размеру совпадает с unsigned long"

Лучше, конечно, такого вообще не упоминать, ибо Страуструп говорит, что не гарантируется, что для хранения указателя всегда хватит int'а. Но если упоминать, то лучше: "большинстве случаев любой указатель по размеру совпадает с int". Long - это вроде процессоронезависемый тип в отличие от int. И unsigned тоже не нужно - размер от этого не меняется. Unsigned - это просто указание компилятору как инерпиртировать содержимое, в большинстве случаев.

[offtop]
Да, точно, сглупил малость. unsigned/signed не суть важно когда говорим о размере. А вот конвертить поинтеры "лучше" все же в unsigned. Но long это еще ой-ой-ой как процессорозависимый тип. На x86 это 32 бита, на АМД64 - 64 бита. АМДшники же кажется придерживаются LP64 модели? А вот int АФАИР сейчас равен 32 битам как на x86, так и на AMD64.
Единственное, не забываем про sizeof(char) <= sizeof(short) <= sizeof(int) <= sizeof(long) [<= sizeof(long long) с недавних пор].
А вот [u]int8_t, [u]int16_t, [u]int32_t, [u]int64_t действительно процессорнезависимы. Да и Vim их к тому же по дефолту подсвечивает . Вывод - они спасут мир Ну если не мир, то во всяком случае теперь разбираясь с новой скаченной библеотекой не придется заучивать как названы процессоронезависимые типы.
[/offtop]

А теперь по топику - где работы со строками? АФАИР сейчас никто не пишет про сишные strXXX? Тогда, пожалуй я начну.

Это сообщение отредактировал(а) Mayk - 2.6.2005, 19:10

И вообще, что за дела с этими строками?! То CString, то AnsiString, то char*.... Куда деваться от разнообразия?!

"Большой выбор хуже отсутствия выбора" :-)

Цитата(kometa_triatlon @ 1.6.2005, 17:58)

Ну так и все, что ты написал и то, что пишешь, и то, что будешь писать, и то, о чем еще не знаешь - все ведь в книгах описано

И? Я об этом в паре постов назад говорил. Просто лично мне к примеру значительно удобнее и проще побродить по форуму, чем ехать куда-то покупать какие-то книги. Я даже больше скажу: в инете уже есть всё, о чём я пишу и о чём я буду писать! И что это даёт? Загляни в репу ко мне - неужели ты думаешь, что Чип с Сергей.Z навешали мне просто так репейники? Значит оно надо! Не буду описывать зачем - лень Да это и роли не играет. Думаю флуд на тему "а оно всё надо?" можно прекратить. Если просят - значит надо.

Сейчас чуть времени малова-то. Допишу статьи позже...
Добавлено @ 11:53

Цитата(PGsoft @ 4.6.2005, 23:25)

"Большой выбор хуже отсутствия выбора" :-)

Некоторые, вроде Gepard'а, пишут свои классы. И ни в чём не проигрывают - свой класс можно всегда настроить под себя и тратить от того на программы значительно меньше времени.

ManiaK

Цитата

Некоторые, вроде Gepard'а, пишут свои классы. И ни в чём не проигрывают - свой класс можно всегда настроить под себя и тратить от того на программы значительно меньше времени.

MSVC: есть CString и std::basic_string
Borland: есть AnsiString и std::basic_string
Еще где-то: есть Что-то и std::basic_string
У Вас: есть Что-то и std::basic_string

Так может досточно знать std::basic_string? И не нужно ничего настраивать и тратить время

Цитата(bel_nikita @ 7.6.2005, 12:16)

Так может досточно знать std::basic_string?  И не нужно ничего настраивать и тратить время

Твоё личное мнение, не забывай. Американцы тоже говорили Ираку: "Зашем вам строить какой-то режим, когды есть Демократия?" Результаты известны.

А если серьёзно, зависит сильно от личности. У меня например от всего STL вообще la blavou . Я эстет даже в программировании и стиль, в котором написана эта библиотека мне очень напоминает то, как Си-шники пишут на языке Си++. И таких, как я, не так уж и мало.

Цитата

А если серьёзно, зависит сильно от личности. У меня например от всего STL вообще la blavou . Я эстет даже в программировании и стиль, в котором написана эта библиотека мне очень напоминает то, как Си-шники пишут на языке Си++. И таких, как я, не так уж и мало.

Не знаю, какую реализацию ты имеешь ввиду, но STLport написана на ура.
А то, что STL и la blavou, то мне кажется, просто напросто от незнания и нежелания

Цитата(ManiaK @ 7.6.2005, 16:48)

У меня например от всего STL вообще la blavou . Я эстет даже в программировании и стиль, в котором написана эта библиотека мне очень напоминает то, как Си-шники пишут на языке Си++. И таких, как я, не так уж и мало.

Впервые в жизни слышу подобное утверждение Во многом STL упрекают, в частности, в кривом дизайне, но то, что она написана в стиле Си... (Степанов не похож на Си-шника, который пишет на языке Си++, имхо).

Под словом стиль в данном случае подразумевается нечто иное. Вот это:

Цитата

Во многом STL упрекают, в частности, в кривом дизайне

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

Ребята, извините за критику, но на мой взгляд вы не тем занялись. Склеивание строк обсуждается в любом учебнике по программированию на С++. Там же можно найти и препроцессорный способ(операцией ##), и string, и использование strcat. Да в конце концов можно MSDN полистать.

На мой взгляд самый удoбный класс для работы со строками это QString, но это уже из другой оперы.

Код

void AString::applyString(char* str) {     if (!str)         return;     if (!data)     {         data = new char[strlen(str) + 1];         memcpy(data, str, strlen(str));         data[strlen(str)] = 0;         return;     }     char *tmp = new char[strlen(data) + 1];     memcpy(tmp, data, strlen(data));     tmp[strlen(data)] = 0;     delete [] data;     data = new char[strlen(tmp) + strlen(str) + 1];     memcpy(data, tmp, strlen(tmp));     for (unsigned int i = 0; i < strlen(str); i++)         data[strlen(tmp) + i] = str[i];     data[strlen(tmp) + strlen(str)] = 0;     delete [] tmp;          length += strlen(str); }

Добавляет к data строку str.
Добавлено @ 15:52
data определён как char* data в классе.

gepard
А зачем каждый раз вычислять strlen(str)? Я думаю одного раза будет достаточно
И на вход нужно подавать conat char* str . Кажись

ManiaK

Цитата

Под словом стиль в данном случае подразумевается нечто иное. Вот это: Во многом STL упрекают, в частности, в кривом дизайне

Давайте возьмем std::string и ваш класс строки и сравним, где кривость дизайна проявиться

Это сообщение отредактировал(а) bel_nikita - 9.6.2005, 16:10

Сниму шляпу перед тем, кто законкенатит быстрее.

Код

void String::append(const char* appendMe) {    if(!appendMe)         return;    int srcLen = data ? strlen(data) : 0;    int appLen=strlen(appendMe);    char* tmp = new char[  srcLen + appLen+1  ];    ((char*)memcpy(((char*)memcpy(tmp, data, srcLen)) + srcLen,                   appendMe, appLen))[appLen+srcLen]=0;    delete data;    data = tmp; }

Это сообщение отредактировал(а) Mayk - 9.6.2005, 16:49

ИМХО: Только мне кажется если есть класс String, то там можно хранить текущую длинну data, а не выполнять все время strlen(data)

Цитата(bel_nikita @ 9.6.2005, 20:44)

ИМХО: Только мне кажется если есть класс String, то там можно хранить текущую длинну data, а не выполнять все время strlen(data)

Верно. Просто версия старая.