Лабораторная работа №5. ПРОГРАММИРОВАНИЕ И ИСПОЛЬЗОВАНИЕ ФУНКЦИЙ

ПРОГРАММИРОВАНИЕ И ИСПОЛЬЗОВАНИЕ ФУНКЦИЙ

Цель работы

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

Задание 1

1. Написать функцию, подсчитывающую количество слов, символов и предложений в тексте. Текст вводится с клавиатуры в динамический массив, указатель на который передается функции в качестве параметра.

2. Написать функцию, конвертирующую в тексте, указатель на который передан ей в качестве параметра, большие буквы на маленькие и наоборот.

3. Написать функцию перевода десятичного числа в шестнадцатеричное.

4. Написать функцию подсчета пробелов, символов табуляции и новой строки в тексте. Текст читается из файла, имя которого передается функции в качестве параметра.

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

6. Написать функцию, переворачивающую символьную строку (располагает символы в обратном порядке). Указатель на строку передается функции в качестве параметра.

7. Написать функцию, которая устанавливает месяц и число по порядковому номеру дня, переданного ей в качестве параметра.

8. Написать функцию, располагающую слова в тексте в алфавитном порядке. Текст читается из файла, имя которого передается функции в качестве параметра.

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

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

Методические указания для выполнения задания

Определение функции имеет вид:

тип_функции имя_функции(список параметров)

{ тело функции

[ return (выражение);]

}

Вот простой пример полного определения функции:

int max (int a,int b,int c)

{

int m = (a > b) ? a : b;

return (m > c) ? m : c;

}

где int является спецификатором типа; max - имя функции; (int a, int b, int c) - список параметров функции; { ... } - блок, задающий текст функции.

Обращение к функции (вызов функции) в программе - это указание ее имени со списком фактических аргументов. Например:

int a ,d=10;

a=max(5, 20, d);// обращение к функции max,5,20,d - фактические аргументы

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

void print(int value=1, char*name="Номер дома: "){

cout<<"\n"<<name<<value;

}

Вызовы:

1.print();

Вывод: Номер дома: 1

2. print(15);

Вывод: Номер дома: 15

3. print(6, "Размерность пространства");

Вывод: Размерность пространства: 6

Некоторые функции в С++ можно определить с использованием служебного слова inline. Такая функция называется подставляемой или встраиваемой.

Например: функция возвращает расстояние от точки с координатами(x2,y2)(по умолчанию центр координат) до точки с координатами (x1,y1).

inline float Line(float x1,float y1,float x2=0, float y2=0){

return sqrt(pow(x1-x2,2)+pow(y1-y2,2));

}

void main()

{

cout<<"x2=0,y2=0, x1=10,y1=5; line="<<Line(10,5)<<endl;

cout<<"x2=21,y2=-12,x1=10,y1=5; line="<<Line(10,5,21,-12)<<endl;

}

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

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

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

Определение функции спеременным числом параметров:

тип имя (явные параметры, ...)

{

тело функции

}

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

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

· известен признак конца списка параметров.

Пример 1. Найти среднее арифметическое последовательности чисел. Известно количество параметров, которое передается как обязательный параметр.

float sum(int k, ...){

int *p=&k;//настроили указатель на параметр k

int s=0;

for(;k!=0;k--)s+=*(++p);

return s/k;

}

void main()

{

cout<<"\n4+6="<<sum(2,4,6);//находит среднее арифметическое 4+6

cout<<"\n1+2+3+4="<<sum(4,1,2,3,4);//находит среднее арифметическое 1+2+3+4

}

Для доступа к списку параметров используется указатель *p типа int. Он устанавливается на начало списка параметров в памяти, а затем перемещается по адресам фактических параметров (++p).

Пример 2. Найти среднее арифметическое последовательности чисел. Известен признак конца списка параметров

int sum(int k, ...){

int *p=&k;//настроили указатель на параметр k

int s=*p;//значение первого параметра присвоили s

for(int i=1;p!=0;i++)//пока нет конца списка

s+=*(++p);

return s/(i-1);

}

void main()

{

cout<<"\n4+6="<<sum(4,6,0);//находит среднее арифметическое 4+6

cout<<"\n1+2+3+4="<<sum(1,2,3,4,0);//находит среднее арифметическое 1+2+3+4

}

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

Правила описания перегруженных функций:

1. Перегруженные функции должны находиться в одной области видимости.

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

3. Функции не могут быть перегружены, если описание их параметров отличается только модификатором const или наличием ссылки. Например, функции int&f1(int&,const int&){...} и int f1(int,int){...} – не являются перегруженными, т. к. компилятор не сможет узнать какая из функций вызывается: нет синтаксических отличий между вызовом функции, которая передает параметр по значению и функции, которая передает параметр по ссылке.

Пример:

int max(int a,int b){

if(a>b)return a;

else return b;

}

char *max(char*a,char*b){

if(strcmp(a,b)>0) return a;

else return b;

}

void main()

{

int a1,b1;char s1[20];char s2[20];

cout<<"\nfor int:\n";cout<<"a=?";cin>>a1;

cout<<"b=?";cin>>b1;cout<<"\nMAX="<<max(a1,b1)<<"\n";

cout<<"\nfor char*:\n";cout<<"a=?";cin>>s1;cout<<"b=?";cin>>s2;

cout<<"\nMAX="<<max(s1,s2)<<"\n";

}

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

template <class имя_типа [,class имя_типа]>

заголовок_функции { тело функции }

Таким образом, шаблон семейства функций состоит из 2 частей – заголовка шаблона: template <список параметров шаблона> и обыкновенного определения функции, в котором вместо типа возвращаемого значения и/или типа параметров, записывается имя типа, определенное в заголовке шаблона.

Пример 1. Шаблон функции, которая находит абсолютное значение числа любого типа

template <class type> //type – имя параметризируемого типа

type abs(type x){

if(x<0)return -x;

else return x;

}

Шаблон служит для автоматического формирования конкретных описаний функций по тем вызовам, которые компилятор обнаруживает в программе. Например, если в программе вызов функции осуществляется как abs(-1.5), то компилятор сформирует определение функции double abs(double x){...}.

Пример 2. Шаблон функции, которая меняет местами две переменныe

template <class T>//T – имя параметризируемого типа

void change(T*x,T*y){

T z=*x;

*x=*y;

*y=z;

}

Вызов этой функции может быть:

long k=10,l=5;

change(&k,&l);

Компилятор сформирует определение:

void change(long*x,long*y){

long z=*x;

*x=*y;

*y=z;

}

Пример 3.

template <class Data>

Data &rmax(int n,Data a[]){

int im=0;

for(int i=0;i<n;i++)

if(a[im]<a[i])im=i;

return a[im];//возвращает ссылку на максимальный элемент в массиве

}

void main()

{

int n=4;

int x[]={10,20,30,15};

cout<<"\nrmax(n,x)="<<rmax(n,x)<<"\n";

for(int i=0;i<n;i++)

cout<<x[i]<<" ";

cout<<"\n";

float y[]={10.4,20.2,30.6,15.5};

cout<<"\nrmax(n,y)="<<rmax(n,y)<<"\n";

for(int i=0;i<n;i++)

cout<<y[i]<<" ";

cout<<"\n";

}

Результаты:

rmax(n,x)=30

10 20 30 15

rmax(n,y)=30.6

10.4 20.2 30.6 15.5

Основные свойства параметров шаблона функций:

· Имена параметров должны быть уникальными во всем определении шаблона.

· Список параметров шаблона не может быть пустым.

· В списке параметров шаблона может быть несколько параметров, каждый из них начинается со слова class.

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

Указатель на функцию определяется следующим образом:

тип_функции (*имя_указателя)(спецификация параметров)

Примеры:

1. int f1(char c){.... }//определение функции

int(*ptrf1)(char);//определение указателя на функцию f1

2. char*f2(int k,char c){....}//определение функции

char*ptrf2(int,char);//определение указателя

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

(*имя_указателя)(список фактических параметров);

Пример.

void f1(){

cout<<"\nfunction f1";}

void f2(){

cout<<"\nfunction f2";}

void main()

{

void(*ptr)();//указатель на функцию

ptr=f2;//указателю присваивается адрес функции f2

(*ptr)();//вызов функции f2

ptr=f1;//указателю присваивается адрес функции f1

(*ptr)();//вызов функции f1с помощью указателя

}

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

void (*ptr)()=f1;

Указатели и функции могут быть объединены в массивы.

Например, float( *ptrMas[4]) (char) – описание массива, который содержит 4 указателя на функции. Каждая функция имеет параметр типа char и возвращает значение типа float. Обратиться к такой функции можно следующим образом:

float a=(*ptrMas[1])('f');//обращение ко второй функции

Пример.

void f1(){

cout<<"\nThe end of work";

exit(0);}

void f2(){

cout<<"\nThe work #1";}

void f3(){

cout<<"\nThe work #2";}

void main()

{

void(*fptr[])()={f1,f2,f3};

int n;

while(1){//бесконечный цикл

cout<<"\n Enter the number";

cin>>n;

fptr[n]();//вызов функции с номером n

}

}

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

typedef float(*fptr)(float);//тип – указатель на функцию

Пример: решение уравнения методом половинного деления. уравнение передается с помощью указателя на функцию

float root(fptr f, float a, float b, float e)

{

float x;

do

{

x=(a+b)/2;

if ((*f)(a)*f(x)<0)b=x; else a=x;

}

while((*f)(x)>e&&fabs(a-b)>e);

return x;

}

float testf(float x)

{

return x*x-1;

}

void main(){

float res=root(testf,0,2,0.0001);

cout<<"\nX="<<res;

}

Подобно указателю на функцию определяется и ссылка на функцию:

тип_функции (&имя_ссылки) (параметры) инициализирующее_выражение;

Пример.

int f(float a,int b){...}//определение функции

int(&fref)(float,int)=f;//определение ссылки

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

Пример.

void f(char c){

cout<<"\n"<<c;

}

void main()

{

void (*pf)(char);//указатель на функцию

void(&rf)(char)=f;//ссылка на функцию

f('A');//вызов по имени

pf=f;//указатель ставится на функцию

(*pf)('B');//вызов с помощью указателя

rf('C');//вызов по ссылке

cout<<"\n";

}

Приложения

Приложение А

«Элементы языка С/C++. Операции и операторы»

1. Комментарии

Символы /* задают начало комментария, заканчивающегося символами */. Комментарии не могут быть вложенными.

Символы // начинают комментарий, который заканчивается в конце строки, на которой они появились.

2. Идентификаторы (имена)

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

3. Ключевые слова

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

auto	continue	else	for	long	signed	switch	void
break	default	enum	goto	register	sizeof	typedef	while
case	do	extern	if	return	static	union
char	double	float	int	short	struct	unsigned

4.Константы

4.1 Целые константы

Целая константа, состоящая из последовательности цифр, считается восьмеричной, если она начинается с 0 (цифры ноль), и десятичной в противном случае. Цифры 8 и 9 не являются восьмеричными цифрами. Последовательность цифр, которой предшествует 0х или 0Х, воспринимается как шестнадцатеричное целое. В шестнадцатеричные цифры входят буквы от а или А до f или F, имеющие значения от 10 до 15. Десятичная константа, значение которой превышает наибольшее машинное целое со знаком, считается длинной (long); восьмеричная и шестнадцатеричная константа, значение которой превышает наибольшее машинное целое со знаком, считается long; в остальных случаях целые константы считаются int.

4.2 Явно заданные длинные константы

Десятичная, восьмеричная или шестнадцатеричная константа, за которой непосредственно стоит l (латинская буква "эль") или L, считается длинной константой.

4.3 Символьные константы

Символьная константа состоит из символа, заключенного в одиночные кавычки (апострофы), как, например, 'х'. Значением символьной константы является численное значение символа в машинном наборе символов (алфавите). Символьные константы считаются данными типа int.

Некоторые неграфические символы, одиночная кавычка ' и обратная косая \, могут быть представлены в соответствие со следующей таблицей escape-последовательностей:

символ новой строки NL(LF) \n

горизонтальная табуляция NT \t

вертикальная табуляция VT \v

возврат на шаг BS \b

возврат каретки CR \r

перевод формата FF \f

обратная косая \ \\

одиночная кавычка (апостроф) ' \'

набор битов 0ddd \ddd

набор битов 0xddd \xddd

Escape-последовательность \ddd состоит из обратной косой, за которой следуют 1, 2 или 3 восьмеричных цифры, задающие значение требуемого символа. Специальным случаем такой конструкции является \0 (не следует ни одной цифры), задающая пустой символ NULL. Escape-последовательность \xddd состоит из обратной косой, за которой следуют 1, 2 или 3 шестнадцатеричных цифры, задающие значение требуемого символа. Если следующий за обратной косой символ не является одним из перечисленных, то обратная косая игнорируется.

Примеры:

"Это символьная строка\n"

"Первый \\ Второй"

"\"Да, конечно,\"— сказала она."

"Следующая строка — пустая:"

""

4.4 Константы с плавающей точкой

Константа с плавающей точкой состоит из целой части, десятичной точки, мантиссы, е или Е и целого показателя степени (возможно, но не обязательно, со знаком). Целая часть и мантисса обе состоят из последовательности цифр. Целая часть или мантисса (но не обе сразу) может быть опущена; или десятичная точка, или е(Е) вместе с целым показателем степени (но не обе части одновременно) может быть опущена. Константа с плавающей точкой имеет тип double.

Примеры констант с плавающей точкой:

15.75

1.575Е1

1575е-2

25.

.75

.0075е2

5. Основные типы

Типы С++ можно разделить на простые и составные. К простым типам относят типы, которые характеризуются одним значением. В С++ определено 6 простых типов данных:

int (целый)

целочисленные

char (символьный)

wchar_t (расширенный символьный)

с плавающей точкой (число=мантисса х 10к )

bool (логический)

float(вещественный)

double (вещественный с двойной точностью)

Существует 4 спецификатора типа, уточняющих внутреннее представление и диапазон стандартных типов

short (короткий)

long (длинный)

signed (знаковый)

unsigned (беззнаковый).

Тип данных void (пустой) определяет пустое множество значений. Значение (несуществующее) объекта void нельзя использовать никаким образом, не могут применяться ни явное, ни неявное преобразования. Поскольку пустое выражение обозначает несуществующее значение, такое выражение такое выражение может использоваться только как оператор выражение или как левый операнд в выражении с запятой. Выражение может явно преобразовываться к типу void.

Области значений

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

Таблица 1-Размер памяти и область значений типов

Тип	Представление в памяти	Область значений
char	1 байт	от -128 до 127
int	зависит от реализации
short	2 байта	от -32768 до 32767
long	4 байта	от -2.147.483.648 до 2.147.483.647
unsigned char	1 байт	от 0 до 255
unsigned	зависит от реализации
unsigned short	2 байта	от 0 до 65535
unsigned long	4 байта	от 0 до 4.294.967.295
float	4 байта	стандартный формат IEEE
double	8 байтов	стандартный формат IEEE
long double	10 байтов	стандартный формат IEEE

6. Производные типы

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

­ массивы объектов данного типа;

­ функции, получающие аргументы данного типа и возвращающие объекты данного типа;

­ указатели на объекты данного типа;

­ ссылки на объекты данного типа;

­ константы, являющиеся значениями данного типа;

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

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

В целом эти способы конструирования объектов могут применяться рекурсивно.

Объект типа void* (указатель на void) можно использовать для указания на объекты неизвестного типа.

7. Некоторые операции языка

Унарные операции

Унарная операция * означает косвенное обращение: выражение должно быть указателем и результатом будет lvalue, ссылающееся на объект, на который указывает выражение. Если выражение имеет тип "указатель на ...", то тип результата есть "...".

Результатом унарной операции & является указатель на объект, на который ссылается операнд. Операнд должен быть lvalue. Если выражение имеет тип "...", то тип результата есть "указатель на ...".

Результатом унарной операции + является значение ее операнда после выполнения обычных арифметических преобразований. Операнд должен быть арифметического типа.

Результатом унарной операции - является отрицательное значение ее операнда. Операнд должен иметь целый тип. Выполняются обычные арифметические преобразования. Отрицательное значение беззнаковой величины вычислятся посредством вычитания ее значения из 2n, где n -число битов в целом типа int.

Результатом операции логического отрицания ! является 1, если значение операнда 0, и 0, если значение операнда не 0. Результат имеет тип int. Применима к любому арифметическому типу или к указателям.

Операция ~ дает дополнение значения операнда до единицы. Выполняются обычные арифметические преобразования. Операнд должен иметь интегральный тип.

Увеличение и Уменьшение

Операнд префиксного ++ получает приращение. Операнд должен быть адресным . Значением является новое значение операнда, но оно не адресное. Выражение ++x эквивалентно x+=1. По поводу данных о преобразованиях см. обсуждение операций сложения и присваивания.

Операнд префиксного -- уменьшается аналогично действию префиксной операции ++.

Значение, получаемое при использовании постфиксного ++, есть значение операнда. Операнд должен быть адресным. После того, как результат отмечен, объект увеличивается так же, как и в префиксной операции ++. Тип результата тот же, что и тип операнда.

Значение, получаемое при использовании постфиксной --, есть значение операнда. Операнд должен быть адресным. После того, как результат отмечен, объект увеличивается так же, как и в префиксной операции ++. Тип результата тот же, что и тип операнда.

Оператор sizeof

Оператор sizeof позволяет выяснить, сколько байт занимает тот или иной тип. В качестве параметра он принимает или название типа, или переменную соответствующего типа. Вот пример:

int z; cout<<sizeof(int)<<"\n"; //Выведется 4. cout<<sizeof(z)<<"\n"; //Выведется 4.

Параметр может быть не только встроенным типом. Пример со структурой:

struct vector{ float x; float y;};void main(){ vector s; cout<<sizeof(s)<<"\n"; //Выведется 8.}

Пример выведет 8, так как float занимает 4 байта и в нашей структуре 2 переменной типа float.

Явное Преобразование Типа

Простое_имя_типа, возможно, заключенное в скобки, за которым идет заключенное в скобки выражение (или список_выражений, если тип является классом с соответствующим образом описанным конструктором) влечет преобразование значения выражения в названный тип. Чтобы записать преобразование в тип, не имеющий простого имени, имя_типа должно быть заключено в скобки. Если имя типа заключено в скобки, выражение заключать в скобки необязательно. Такая запись называется приведением к типу.

Указатель может быть явно преобразован к любому из интегральных типов, достаточно по величине для его хранения. То, какой из int и long требуется, является машинно-зависимым. Отображающая функция также является машинно-зависимой, но предполагается, что она не содержит сюрпризов для того, кто знает структуру адресации в машине.

Мультипликативные операции

Мультипликативные операции *, / и % группируют слева направо. Выполняются обычные арифметические преобразования.

мультипликативное_выражение:

выражение * выражение

выражение / выражение

выражение % выражение

Бинарная операция * определяет умножение. Операция * ассоциативна и выражения с несколькими умножениями на одном уровне могут быть реорганизованы компилятором.

Бинарная операция / определяет деление. При делении положительных целых округление осуществляется в сторону 0, но если какой-либо из операндов отрицателен, то форма округления является машинно-зависимой. На всех машинах, охватываемых данным руководством, остаток имеет тот же знак, что и делимое. Всегда истинно, что (a/b)*b + a%b равно a (если b не 0).

Бинарная операция % дает остаток от деления первого выражения на второе. Выполняются обычные арифметические преобразования. Операнды не должны быть числами с плавающей точкой.

Аддитивные операции

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

аддитивное_выражение:

выражение + выражение

выражение - выражение

Результатом операции + является сумма операндов. Можно суммировать указатель на объект массива и значение целого типа. Последнее во всех случаях преобразуется к смещению адреса с помощью умножения его на длину объекта, на который указывает указатель. Результатом является указатель того же типа, что и исходный указатель, указывающий на другой объект того же массива и соответствующим образом смещенный от первоначального объекта. Так, если P есть указатель на объект массива, то выражение P+1 есть указатель на следующий объект массива.

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

Результатом операции - является разность операндов. Выполняются обычные арифметические преобразования. Кроме того, значение любого целого типа может вычитаться из указателя, в этом случае применяются те же преобразования, что и к сложению.

Если вычитаются указатели на объекты одного типа, то результат преобразуется (посредством деления на длину объекта) к целому, представляющему собой число объектов, разделяющих объекты, указанные указателями. В зависимости от машины результирующее целое может быть или типа int, или типа long;

Операции сдвига

Операции сдвига << и >> группируют слева направо. Обе выполняют одно обычное арифметическое преобразование над своими операндами, каждый из которых должен быть целым. В этом случае правый операнд преобразуется к типу int; тип результата совпадает с типом левого операнда. Результат не определен, если правый операнд отрицателен или больше или равен длине объекта в битах.

сдвиговое_выражение:

выражение << выражение

выражение >> выражение

Значением Е1 << Е2 является Е1 (рассматриваемое как битовое представление), сдвинутое влево на Е2 битов; освободившиеся биты заполняются нулями. Значением Е1 >> Е2 является Е1 , сдвинутое вправо на Е2 битовых позиций. Гарантируется, что сдвиг вправо является логическим (заполнение нулями), если Е1 является unsigned; в противном случае он может быть арифметическим (заполнение копией знакового бита).

Операции отношения

Операции отношения (сравнения) группируют слева направо, но этот факт не очень-то полезен: a < b < c не означает то, чем кажется.

выражение_отношения:

выражение < выражение

выражение > выражение

выражение <= выражение

выражение >= выражение

Операции < (меньше чем), > (больше чем), <= и >= все дают 0, если заданное соотношение ложно, и 1, если оно истинно. Тип результата int. Выполняются обычные арифметические преобразования. Могут сравниваться два указателя; результат зависит от относительного положения объектов, на которые указывают указатели, в адресном пространстве. Сравнение указателей переносимо только если указатели указывают на объекты одного массива.

Операции равенства

выражение_равенства:

выражение == выражение

выражение != выражение

Операции == и != в точности аналогичны операциям сравнения за исключением их низкого приоритета. (Так, a < b == c < d есть 1 всегда, когда a < b и c < d имеют одинаковое истинностное значение.)

Указатель может сравниваться с 0.

Операция побитовое И

И-выражение: выражение & выражение

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

Операция побитовое исключающее ИЛИ

исключающее_ИЛИ_выражение:

выражение ^ выражение

Операция ^ ассоциативна, и выражения, содержащие ^, могут реорганизовываться. Выполняются обычные арифметические преобразования; результатом является побитовая функция исключающее ИЛИ операндов. Операция применяется только к целым операндам.

Операция побитовое включающее ИЛИ

включающее_ИЛИ_выражение:

выражение | выражение

Операция | ассоциативна, и выражения, содержащие |, могут реорганизовываться. Выполняются обычные арифметические преобразования; результатом является побитовая функция включающее ИЛИ операндов. Операция применяется только к целым операндам.

Операция логическое И

логическое_И_выражение:

выражение && выражение

Операция && группирует слева направо. Она возвращает 1, если оба операнда ненулевые, и 0 в противном случае. В противоположность операции & операция && гарантирует вычисление слева направо; более того, второй операнд не вычисляется, если первый операнд есть 0.

Операнды не обязаны иметь один и тот же тип, но каждый из них должен иметь один из основных типов или быть указателем. Результат всегда имеет тип int.

Операция логическое ИЛИ

логическое_ИЛИ_выражение:

выражение || выражение

Операция || группирует слева направо. Она возвращает 1, если хотя бы один из ее операндов ненулевой, и 0 в противном случае. В противоположность операции | операция || гарантирует вычисление слева направо; более того, второй операнд не вычисляется, если первый операнд не есть 0.

Операнды не обязаны иметь один и тот же тип, но каждый из них должен иметь один из основных типов или быть указателем. Результат всегда имеет тип int.

Условная операция

условное_выражение:

выражение ? выражение : выражение

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

Операции присваивания

Есть много операций присваивания, все группируют слева направо. Все в качестве левого операнда требуют lvalue, и тип выражения присваивания тот же, что и у его левого операнда. Это lvalue не может ссылаться на константу (имя массива, имя функции или const). Значением является значение, хранящееся в левом операнде после выполнения присваивания.

выражение_присваивания:

выражение операция_присваивания выражение

операция_присваивания: одна из

= += -= *= /= %= >>= <<= &= ~= |=

В простом присваивании с = значение выражения замещает собой значение объекта, на который ссылается операнд в левой части. Если оба операнда имеют арифметический тип, то при подготовке к присваиванию правый операнд преобразуется к типу левого. Если аргумент в левой части имеет указательный тип, аргумент в правой части должен быть того же типа или типа, который может быть преобразован к нему. Оба операнда могут быть объектами одного класса. Могут присваиваться объекты некоторых производных классов.

Операция запятая

запятая_выражение:

выражение , выражение

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

f (a,(t=3,t+2),c)

имеет три параметра, вторым из которых является значение 5.

8. Основные операторы

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

Условный оператор

Есть два вида условных операторов

if ( выражение ) оператор

if ( выражение ) оператор else оператор

В обоих случаях вычисляется выражение, и если оно не ноль, то выполняется первый подоператор. Во втором случае второй подоператор выполняется, если выражение есть 0. Как обычно, неоднозначность "else" разрешается посредством того, что else связывается с последним встреченным if, не имеющим else.

Оператор whilе

Оператор while имеет вид

while ( выражение ) оператор

Выполнение подоператора повторяется, пока значение выражения остается ненулевым. Проверка выполняется перед каждым выполнением оператора.

Оператор dо

Оператор do имеет вид

do оператор while (выражение);

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

Оператор for

Оператор for имеет вид

for ( выражение_1 opt ; выражение_2 opt ; выражение_3 opt )

оператор

Этот оператор эквивалентен следующему:

выражение_1;

while (выражение_2)

{

оператор

выражение_3;

}

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

Каждое или все выражения могут быть опущены. Отсутствие выражения_2 делает подразумеваемое while-предложение эквивалентным while(1); остальные опущенные выражения просто пропускаются в описанном выше расширении.

Оператор switch

Оператор switch вызывает передачу управления на один из нескольких операторов в зависимости от значения выражения. Он имеет вид

switch ( выражение ) оператор

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

case константное_выражение :