Бьерн Страуструп (Стpаустpуп - Книга о C++), страница 7

main () { }

В этой программе определяется функция, называемая main, которая не

имеет параметров и ничего не делает. Фигурные скобки { и } используются в

С++ для группирования операторов. В данном случае они обозначают начало и

конец тела (пустого) функции main. В каждой программе на С++ должна быть

своя функция main(), и программа начинается с выполнения этой функции.

Обычно программа выдает какие-то результаты. Вот программа, которая

выдает приветствие Hello, World! (Всем привет!):

#include <iostream.h>

int main ()

{

cout << "Hello, World!\n";

}

Строка #include <iostream.h> сообщает транслятору, что надо включить в

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

вывода, которые находятся в iostream.h. Без этих описаний выражение

cout << "Hello, World!\n"

не имело бы смысла. Операция << ("выдать") записывает свой второй

параметр в первый параметр. В данном случае строка "Hello, World!\n"

записывается в стандартный выходной поток cout. Строка - это

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

обратной дробной черты \ и непосредственно следующий за ним - обозначают

некоторый специальный символ. В данном случае \n является символом конца

строки (или перевода строки), поэтому он выдается после символов Hello,

world!

Целое значение, возвращаемое функцией main(), если только оно есть,

считается возвращаемым системе значением программы. Если ничего не

возвращается, система получит какое-то "мусорное" значение.

Средства ввода/вывода потоковой библиотеки подробно описываются в

главе 10.

1.3.2 Переменные и арифметические операции

Каждое имя и каждое выражение обязаны иметь тип. Именно тип определяет

операции, которые могут выполняться над ними. Например, в описании

int inch;

говорится, что inch имеет тип int, т.е. inch является целой

переменной.

Описание - это оператор, который вводит имя в программу. В описании

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

использовать имя или выражение.

Основные типы, наиболее приближенные к "аппаратной реальности" машины,

таковы:

char

short

int

long

Они представляют целые числа. Следующие типы:

float

double

long double

представляют числа с плавающей точкой. Переменная типа char имеет

размер, нужный для хранения одного символа на данной машине (обычно это

один байт). Переменная int имеет размер, необходимый для целой арифметики

на данной машине (обычно это одно слово).

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

сочетанием перечисленных типов:

+ (плюс, унарный и бинарный)

- (минус, унарный и бинарный)

* (умножение)

/ (деление)

% (остаток от деления)

То же верно для операций отношения:

== (равно)

!= (не равно)

< (меньше чем)

<= (меньше или равно)

>= (больше или равно)

Для операций присваивания и арифметических операций в С++ выполняются

все осмысленные преобразования основных типов, чтобы их можно было

неограниченно использовать любые их сочетания:

double d;

int i;

short s;

// ...

d = d + i;

i = s * i;

Символ = обозначает обычное присваивание.

1.3.3 Указатели и массивы

Массив можно описать так:

char v [ 10 ]; // массив из 10 символов

Описание указателя имеет такой вид:

char * p; // указатель на символ

Здесь [] означает "массив из", а символ * означает "указатель на".

Значение нижней границы индекса для всех массивов равно нулю, поэтому v

имеет 10 элементов: v [ 0 ] ... v [ 9 ]. Переменная типа указатель может

содержать адрес объекта соответствующего типа:

p = & v [ 3 ]; // p указывает на 4-й элемент массива v

Унарная операция & означает взятие адреса.

1.3.4 Условные операторы и циклы

В С++ есть традиционный набор выбирающих операторов и циклов. Ниже

приводятся примеры операторов if, switch и while.

В следующем примере показано преобразование дюйма в сантиметр и

обратно. Предполагается, что во входном потоке значение в сантиметрах

завершается символом i, а значение в дюймах - символом c:

#include <iostream.h>

int main ()

{

const float fac = 2.54;

float x, in, cm;

char ch = 0;

cout << "enter length: ";

cin >> x; // ввод числа с плавающей точкой

cin >> ch // ввод завершающего символа

if ( ch == 'i' )

{ // дюйм

in = x;

cm = x * fac;

}

else if ( ch == 'c' )

{ // сантиметры

in = x / fac;

cm = x;

}

else

in = cm = 0;

cout << in << " in = " << cm << " cm\n";

}

Операция >> ("ввести из") используется как оператор ввода; cin

является стандартным входным потоком. Тип операнда, расположенного справа

от операции >>, определяет, какое значение вводится; оно записывается в

этот операнд.

Оператор switch (переключатель) сравнивает значение с набором

констант. Проверку в предыдущем примере можно записать так:

switch ( ch )

{

case 'i':

in = x;

cm = x * fac;

break;

case 'c':

in = x / fac;

cm = x;

break;

default:

in = cm = 0;

break;

}

Операторы break используются для выхода из переключателя. Все

константы вариантов должны быть различны. Если сравниваемое значение не

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

Вариант default может и отсутствовать.

Приведем запись, задающую копирование 10 элементов одного массива в

другой:

int v1 [ 10 ];

int v2 [ 10 ];

// ...

for ( int i=0; i<10; i++ ) v1 [ i ] = v2 [ i ];

Словами это можно выразить так: "Начать с i равного нулю, и пока i

меньше 10, копировать i-тый элемент и увеличивать i." Инкремент (++)

переменной целого типа просто сводится к увеличению на 1.

1.3.5 Функции

Функция - это поименованная часть программы, которая может вызываться

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

программу, выдающую степени числа два:

extern float pow ( float, int );

// pow () определена в другом месте

int main ()

{

for ( int i=0; i<10; i++ ) cout << pow ( 2, i ) << '\n';

}

Первая строка является описанием функции. Она задает pow как функцию с

параметрами типа float и int, возвращающую значение типа float. Описание

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

При вызове функции тип каждого фактического параметра сверяется с

типом, указанным в описании функции, точно так же, как если бы

инициализировалась переменная описанного типа. Это гарантирует надлежащую

проверку и преобразования типов. Например, вызов функции pow(12.3,"abcd")

транслятор сочтет ошибочным, поскольку "abcd" является строкой, а не

параметром типа int. В вызове pow(2,i) транслятор преобразует целую

константу (целое 2) в число с плавающей точкой (float), как того требует

функция. Функция pow может быть определена следующим образом:

float pow ( float x, int n )

{

if ( n < 0 )

error ( "ошибка: для pow () задан отрицательный показатель");

switch ( n )

{

case 0: return 1;

case 1: return x;

default: return x * pow ( x, n-1 );

}

}

Первая часть определения функции задает ее имя, тип возвращаемого

значения (если оно есть), а также типы и имена формальных параметров (если

они существуют). Значение возвращается из функции с помощью оператора

return.

Разные функции обычно имеют разные имена, но функциям, выполняющим

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

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

разобраться, какую функцию нужно вызывать. Например, можно иметь две

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

с плавающей точкой:

int pow ( int, int );

double pow ( double, double );

//...

x = pow ( 2,10 ); // вызов pow ( int, int )

y = pow ( 2.0, 10.0 );// вызов pow ( double, double )

Такое многократное использование имени называется перегрузкой имени

функции или просто перегрузкой; перегрузка рассматривается особо в главе

7.

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

ссылке". Рассмотрим определение функции, которая осуществляет взаимообмен

значений двух целых переменных. Если используется стандартный способ

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

void swap ( int * p, int * q )

{

int t = * p;

* p = * q;

* q = t;

}

Унарная операция * называется косвенностью (или операцией

разыменования), она выбирает значение объекта, на который настроен

указатель. Функцию можно вызывать следующим образом:

void f ( int i, int j )

{

swap ( & i, & j );

}

Если использовать передачу параметра по ссылке, можно обойтись без

явных операций с указателем:

void swap (int & r1, int & r2 )

{

int t = r1;

r1 = r2;

r2 = t;

}

void g ( int i, int j )

{

swap ( i, j );

}

Для любого типа T запись T& означает "ссылка на T". Ссылка служит

синонимом той переменной, которой она инициализировалась. Отметим, что

перегрузка допускает сосуществование двух функций swap в одной программе.

1.3.6 Модули

Программа С++ почти всегда состоит из нескольких раздельно

транслируемых "модулей". Каждый "модуль" обычно называется исходным

файлом, но иногда - единицей трансляции. Он состоит из последовательности

описаний типов, функций, переменных и констант. Описание extern позволяет

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

другом исходном файле. Например:

extern "C" double sqrt ( double );

extern ostream cout;

Самый распространенный способ обеспечить согласованность описаний

внешних во всех исходных файлах - поместить такие описания в специальные

файлы, называемые заголовочными. Заголовочные файлы можно включать во все

исходные файлы, в которых требуются описания внешних. Например, описание

функции sqrt хранится в заголовочном файле стандартных математических

функций с именем math.h, поэтому, если нужно извлечь квадратный корень из

4, можно написать:

#include <math.h>

//...

x = sqrt ( 4 );

Поскольку стандартные заголовочные файлы могут включаться во многие

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

ошибки. Так, тело функции присутствует в таких файлах, если только это

функция-подстановка, а инициализаторы указаны только для констант ($$4.3).

Не считая таких случаев, заголовочный файл обычно служит хранилищем для

типов, он предоставляет интерфейс между раздельно транслируемыми частями

программы.

В команде включения заключенное в угловые скобки имя файла (в нашем

примере - <math.h>) ссылается на файл, находящийся в стандартном каталоге

включаемых файлов. Часто это - каталог /usr/include/CC. Файлы, находящиеся

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

кавычки. Поэтому в следующих командах:

#include "math1.h"

#include "/usr/bs/math2.h"

включаются файл math1.h из текущего каталога пользователя и файл

math2.h из каталога /usr/bs.

Приведем небольшой законченный пример, в котором строка определяется в

одном файле, а печатается в другом. В файле header.h определяются нужные

типы:

// header.h

extern char * prog_name;

extern void f ();

Файл main.c является основной программой:

// main.c

#include "header.h"

char * prog_name = "примитивный, но законченный пример";

int main ()

{

f ();

}

а строка печатается функцией из файла f.c:

// f.c

#include <stream.h>

#include "header.h"

void f ()