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

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, а в результате получится совсем не то, что надо. Ну их нафиг эти приведения типов. ИМХО.