Реферат: Turbo C++ Programer`s guide

По устоявшейся традиции, если спецификатор типа опущен, то по умолчанию назначается тип signed int (или, что эквивалентно, int). Однако, в С++ встречаются ситуации, когда отсутствие спецификатора типа ведет к синтаксической неоднозначности, поэтому в практике работы с С++ используется явный ввод всех спецификаторов типа int.

Таксономия типа

Существует четыре базовые категории типа: void, scalar, function и aggregate. Типы scalar и aggregate могут далее подразделяться следующим образом:

- Scalar: арифметический, перечислимый, указатель и в С ++ ссылки

- Aggregate: массив, структура, объединение и в С++ класс

Типы делятся на фундаментальные и производные. К фундаментальным относятся: void, char, int, float и double совместно с short, long, signed, а также некоторые варианты с ними unsigned. Производные типы включают в себя указатели и ссылки на другие типы,массивы других типов, типы функций, типы классов, структуры и объединения.

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

Задав не-пустойтип type (с некоторыми предосторожностями), можно объявлять производные типы следующим образом:

Объявление типов                     Таблица 1.13

struct st (type t1; type t2);  структура st содержит два типа

Ниже показано, как производные типы могут быть объявлены в пределах класса:

class cl (*   // класс cl содержит указатель ptr на тип, плюс

// функцию, принимающую параметр type (C++)

type *ptr;

public:

void func(type*);

Тип void

Void это специальный спецификатор типа, указывающий на отсутствие каких-либо значений. Он задается в следующих ситуациях:

- Пустой список параметров в объявлении функции:

int func(void);   // функция не принимает аргументов

С++ обрабатывает 0 специальным образом. См. раздел "Объявления и прототипы" на стр.60 и примеры кода на стр.61 оригинала.

- Когда объявленная функция не возвращает значений:

void func(int n); // возвращаемое значение отсутствует

- В качестве родового указателя.  Указатель на void является родовым указателем на все что угодно:

void *ptr;  // далее ptr может быть установлен на любой

// объект

- Выражения с проверкой типа:

extern int errfunc();                             // возвращает код ошибки

...

(void) errfunc();                           // значение возврата теряется

Фундаментальные типы

signed и unsigned - это модификаторы, применяемые к интегральным типам.

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

char               int                 signed

double   long                      unsigned

float              short

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

Интегральные типы

Типы char, short, int и long, а также их варианты unsigned называются интегральными типами. Ниже приводятся спецификаторы интегральных типов с помещенными в той же строке синонимами.

Интегральные типы                     Таблица 1.14

char,signed char Если по умолчанию char установлен как signed, то это синонимы

unsigned char

char,unsigned char Если по умолчанию char установлен как

unsigned, то это синонимы

signed char

int,signed int

unsigned,unsigned int

short,short int,signed short int

unsigned short,unsigned short int

long,long int,signed long int

unsigned long,unsigned long int

С типами char,short, int или long можно использовать либо signed, либо unsigned. Если же использовать только сами ключевые слова signed или unsigned, то они означают signed int или unsigned int, соответственно.

В отсутствие слова unsigned обычно принимается тип signed. Исключение возникаетв случае char. Turbo C++ позволяет устанавливатьдля char умолчание signed или unsigned. (Если вы не устанавливали это умолчание сами, то это умолчание будет равно signed). Если умолчание установлено в значение unsigned, то объявление char ch объявит ch как unsigned. Для переопределение этогоумолчания нужно задать signed char ch. Аналогичным образом, если для char установлено умолчание signed, то для объявления ch как unsigned char следует явно указать unsigned char ch.

С int можно использовать либо long, либо short. Если ключевые словаlong или short использованы сами по себе, то они означают long int или short int, соответственно.

ANSI C не устанавливаетразмеры внутреннего представления этих типов, за исключением того, что размеры данных short, int и long образуют неубывающую последовательность"short <= int <= long". Все три типа могут быть одинаковыми. Это существенно для написания мобильных кодов, предназначенных для переноса на другую аппаратную базу.

В Turbo C++ типы int и short эквивалентны, и имеют оба длину 16 бит. long представляет 32-битовые объекты. Их разновидность с ключевым словом signed хранятся вформате дополнения до двух, причем в качестве знакового бита используется MSB (наиболее значащий бит): 0 означает положительное число, 1 - отрицательное (что объясняет диапазоне, приведенные в таблице 1.9). В версиях unsigned дляхранения числа используются все биты, что дает диапазон 0-(2^n-1), где n = 8,16 или

32.

Типы с плавающей точкой

Представления и множества принимаемых значений для типов с плавающей точкой зависят от конкретной реализации; то есть каждая новая реализация компилятора С свободна определять их по-своему. TurboC++ использует форматы с плавающей точкой IEEE. (Приложение А, "Стандарты ANSI, зависимые от реализации" содержит более подробную информацию по этому вопросу.)

float иdoubleпредставляют собой 32- и 64-разрядные типы данных с плавающей точкой, соответственно. long можно использовать с double для получения 80-разрядной точности представления идентификатора с плавающей точкой: long double test_case, например.

Распределяемая для типов с плавающей точкой память показана в таблице 1.9.

Стандартные преобразования

При использовании арифметических выражений, таких как a +b, где a и b - это данные различных арифметических типов, Turbo C++ выполняет передвычислениемопределенные внутренние преобразования. Эти стандартные преобразования включают в себя перевод "низших" типов в "высшие" в интересах точности представления и непротиворечивости данных.

Ниже приводятся шаги, выполняемые Turbo C++для преобразования операндов в арифметических выражениях:

1. Все малые интегральные типы преобразовываются согласно таблице 1.15. После этого любые два значения, участвующие в операции, становятся либо Int (включая модификаторы long и unsigned), либо double, float или long double.

2. Если один из операндов имеет тип long double, то второй операнд также будет преобразован к типу long double.

3. Иначе, если один из операндов имеет тип double, то второй операнд также будет преобразован к типу double.

4. Иначе, если один из операндов имеет тип float, то второй операнд также будет преобразован к типу float.

5. Иначе, если один из операндов имеет тип unsigned long, то второй операнд также будет преобразован к типу unsigned long.

6. Иначе, если один из операндов имеет тип long, то второй операнд также будет преобразован к типу long.

7. Иначе, если один из операндов имеет тип unsigned, то второй операнд также будет преобразован к типу unsigned.

8. В противном случае оба операнда имеют тип Int.

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

Методы стандартных арифметических преобразований Таблица 1.15

Тип   Преобразование вМетод

char   intРасширение нулем или знаком

(в зависимости от умолчания

для типа char)

unsigned char   intЗаполнение старшего байта

нулем (всегда)

signed char   intРасширение знаком (всегда)

short   intТо же значение

unsigned short                    unsigned int То же значение

enum   intТо же значение

Специальные преобразования типов char, int и enum

Обсуждаемые в данном разделе преобразования специфичны для Turbo C++.

Присваивание объекта типа signed char (например,переменной) интегральномуобъекту вызывает автоматическое расширение знаком. Объекты типа signed char используетрасширение знаком всегда; объекты типаunsigned charпри преобразовании вint всегда устанавливают старший байт в ноль.

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

Инициализация

Инициализаторы устанавливают исходное значение,хранимое в объекте (переменные,массивы, структуры, и т.д.). Если вы не инициализируете объект, и он имеет статическую продолжительность существования, то он будет инициализирован по умолчанию, следующим образом:

- нулем, если это объект арифметического типа

- null, если что указатель

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

Синтаксис инициализаторов следующий: инициализатор

= выражение

= (*список-инициализаторов*)<,>*)

(список выражений)

список-инициализаторов

выражение

список-инициализаторов, выражение

(*список-инициализаторов*)<,>*)

Ниже приводятся правила, управляющие инициализаторами:

1. Число инициализаторов в списке инициализаторов не может превышать число инициализируемых объектов.

2. Инициализируемый элемент должен быть типа объекта или массивом неизвестной размерности.

3. Все выражения должны являться константами, если они находятся в одном из следующих мест:

а. в инициализаторе объекта, имеющего статическую длительность (в Turbo C++ не требуется)

b. в списке инициализаторов для массива, структуры или объединения (также допустимы выражения с использованием sizeof)

4. Если объявление идентификатора имеет контекст блока, и идентификатор имеет внешнюю или внутреннюю компоновку, объявление не может иметь инициализатор для идентификатора.

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

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

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

- списком инициализаторов, как описано в следующем разделе

- отдельным выражением с типом, совместимым с объединением или структурой. В этом случае исходное значение объекта берется из выражения.

Массивы, структуры и объединения

Вы инициализируете массивы и структуры (если хотите, то во время объявления) при помощи заключенного в фигурные скобки списка инициализаторов для компонентов илиэлементов рассматриваемого объекта. Инициализаторы даются по возрастанию индекса массивов или номеров компонентов. Инициализация объединенийвыполняется заключенным в фигурные скобки инициализатором для первого компонента объединения. Например, вы можете объявить массив days, предназначенный для подсчета того, сколько раз каждый день недели был в том или ином месяце (предполагая, что каждый день недели был в месяце хотя бы один раз), следующим образом:

int days[7] = (* 1, 1, 1, 1, 1, 1, 1)

Этими правилами можновоспользоваться для инициализации символьных массивов и широких символьных массивов:

1. Можно инициализировать массивы символьного типа с помощью строки литералов, опционально заключенной в фигурные скобки. Каждый символ строки, включая нулевой терминатор, инициализирует последовательно расположенные элементы массива. Например, вы могли объявить:

char name[] = (* "Unknown" *);

установив тем самым массив из восьми элементов, элементы которого равны 'U'(для name[0]), 'n' (для name[1]), и т.д. (включая нулевой терминатор.)

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

Ниже приводится пример инициализации структуры:

struct mystruct (*

int i;

char str[21];

double d;

*) s = (* 20, "Borland", 3.14 *);

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

Простые объявления

Простые объявления идентификаторов переменных имеют следующий шаблон:

тип-данных перем1 <=иниц1>, перем2 <=иниц2>,...;

где перем1, перем2, ... это произвольная последовательность отдельных идентификаторов с опциональными инициализаторами. Каждая из переменных объявляется с указанным типом-данных. Например,

int x = 1, y = 2;

создает две целочисленных переменных x и y (и инициализирует их значениями 1 и 2, соответственно).

Это былиобъявления определения; при этом распределялась память и выполнялась инициализация.

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

В C++ инициализатор статического объекта может являться любым выражением, включающим в себя константы и ранее определенные переменные и функции.

Спецификаторы класса памяти

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

auto               register  typedef

extern   static

Использование спецификатора класса памяти auto

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

Использование спецификатора класса памяти extern

Спецификатор класса памяти extern может быть использован в объявлениях функций и переменных с контекстом файла и с локальным контекстом для обозначения внешнего типа компоновки. В случае переменных сконтекстом файла спецификатор класса памяти extern является умолчанием.При использовании спеременными extern указывает на то,что данная переменная имеетстатическую продолжительность. (Помните, что функции всегда имеютстатическую продолжительность).

Использование спецификатора класса памяти register

Спецификатор класса памяти registerдопустим только в объявлениях локальных переменных и параметров функций. Он эквивалентен класса auto, за исключением того, что компилятору в данном случае делается запрос о размещении при возможности данной переменной в регистре. Распределение для переменной регистра может значительно уменьшить размер программы и увеличить скорость ее выполнения во многих случаях. Однако, поскольку TurboC++ итак предпринимает мерыдля возможного размещения переменных в регистре, необходимость в явном задании ключевого слова register возникает редко.

Turbo C++ позволяет вам выбрать опции размещения переменных в регистрах в диалоговом поле Options \! Compiler \! Optimization. При выборе опции Automatic TurboC++ сделает попытку распределить регистры даже еслиспецификаторы класса памяти register не задавались.

Использование спецификатора класса памяти static

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

В С++ компоненты класса,статические данные, имеет то же значение длявсех вхождений класса. Члены класса, статические функции, не зависят от других вхождений класса.

Использование спецификатора класса памяти typedef

Ключевое слово typedef означает, что вы не объявляете объект, а определяете спецификатор нового типа данных. typedef включается в качестве спецификатора класса памяти вследствие синтаксических, а не функциональных аналогий.

static long int biggy;

typedef long int BIGGY;

Страницы: 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