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

Void – “пустой тип”, используется в случаях когда тип указывать не нужно либо когда тип нужно проигнорировать. Например тип void используется для того чтобы обозначить то, что функция не возвращает значения.

void f();

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

Например: при реализации алгоритма распределения памяти.

7. Операции в С++. Арифметические операции.

1) Унарные – операции с одним аргументом.

a) - –меняет знак.

b) ++ – инкремент (увеличение на 1). Бывают постфиксные и префиксные. В постфиксной форме сначала извлекается значение операнда, затем делается модификация, в префиксной – делается модификация, затем извлекается значение.

c) -- – декремент (уменьшение на 1). Бывают постфиксные и префиксные.

2) Бинарные операции –

a) +, -, * – математические операции. При смешивании аргументов разных типов тип с меньшей точностью приводится к типу с большей точностью.

b) / – деление. При смешивании аргументов разных типов выполняется приведение к типу с большей точностью. Если оба аргументы целые выполняется целочисленное деление.

c) % – взятие остатка от целочисленного деление.

int a=10, b=3;

a/b ->3

c/b ->8.3/3.0

a%b ->1

3) Операции с присваиванием.

= – присваивание. Возвращает виды значения. И ту величину которая была вычислена в левой части

int a=10

cout << (a=a*3)<<endl;

*= - операция умножения с присваиванием. В таких операциях сначала левая часть умножается на правую, а затем полученное выражение присваивается в левую часть.

a*=b эквивалентно a=a*b

a+=b эквивалентно a=a+b

a-=b эквивалентно a=a-b

и т.д. для остальных арифметических операций.

8. Операции в С++. Присваивание.

= – присваивание. Возвращает виды значения. И ту величину которая была вычислена в левой части

int a=10

cout << (a=a*3)<<endl;

Операции с присваиванием.

*= - операция умножения с присваиванием. В таких операциях сначала левая часть умножается на правую, а затем полученное выражение присваивается в левую часть.

a*=b эквивалентно a=a*b

a+=b эквивалентно a=a+b

a-=b эквивалентно a=a-b

и т.д. для остальных арифметических операций.

9. Операции в С++. Операции отношения.

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

1. < –меньше

2. > – больше

3. <= – меньше либо равно

4. >= – больше либо равно

5. == –равно

6.!= – не равно

Пример:

Int a=3;

Int b=4;

bool z=a<4; //результат true

bool f=a>b; //результат false

10. Операции в С++. Логические операции.

Логические операции необходимы для формирования сложных условий.

! – логическое отрицание.

&& – логическое «и»

|| – логическое «или»

Логические операции по приоритетам находятся в других группах по сравнению с арифметическим и операциями отношения

a-b>=10 равнозначно (a-b)>=10

((a-b)>=10)&&(c<100) равнозначно a-b>=10&&c<100

11. Операторы в С++. Выражение.

Любая комбинация переменных, констант и операций, приводящая к вычислению некоторого значения, называется выражением. Например, выражениями являются конструкции alpha+12, где alpha –переменная или константа. Результатом выполнения всех операций, входящих в состав выражения, является значение. Так, например, если alpha равно 7 значение выражения, приведенного выше, равно 19.

12. Операторы в С++. Составной оператор.

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

{<список_операторов>

или

<пусто>}

<список_операторов> ->

<оператор1>

[<оператор2>]

[<операторN>]

Пример составных операторов.

{ a++;

b--; }

{

int a=10;

b+=a;

}

if(a%10==0) { } else

cout<<”Не кратно 10”<<endl;

13. Операторы в С++. Оператор if.

Оператор выбора if. Имеет полную сокращённую форму

Полная форма:

if(<выражение>)

<оператор1>;

else

<оператор2>;

Сокращённая форма:

if(<выражение>)

<оператор1>;

Скобки () – часть оператора if. Они обязательны по синтаксису.

; – является частью синтаксиса if, они обязательны кроме случаев, когда оператор 1 и/или оператор 2 являются составными.

В случае вложенных операторов if, else относится к ближайшему if.

Выражение обрабатывается как условное.

if(a>b) {

cout<<”!!!”<<endl;

a++; }

else

{cout<<”&&&”<<endl;

a--; }

if (a%10)

cout<<”Не кратно 10”<<endl;

if(a%10!=10)

cout<<”Не кратно 10”<<endl;

14. Операторы в С++. Оператор while.

Оператор while.

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

while(<выражение>);

<оператор>;

Оператор выполняется до тех пор, пока тело цикла – истина.

while (a<0)

a++;

15. Операторы в С++. Оператор do … while.

оператор do while

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

do

<оператор>;

while(<выражение>);

do

a++;

while(a<0)

16. Операторы в С++. Оператор continue.

оператор continue

Оператор перехода continue выполняет переход к следующей итерации цикла. Соответствующие приёмы использования похожи на приёмы оператора break.

for (k=0,s=0,x=1;x!=0;) {

cin>>x;

if (x<=0)

continue;

k++; s+=x;

}

При срабатывании if, continue начнёт новую итерацию цикла.

17. Операторы в С++. Оператор break.

оператор break.

Прерывает выполнение оператора цикла или оператора switch.

int i;

for(i=0;i<10;i+=2){

<оператор>

if(<выражение>);

break

<оператор>

}

Если срабатывает break, то цикл будет прерван.

int s=0, x;

for (int i=0; i<100;i++) {

cin>>x;

if(x==0)

break;

s+=x;

cout<<”s=”<<s<<endl;

18. Операторы в С++. Оператор switch.

Оператор выбора Switch

Switch(<выражение>) {

case <константа1>:

<список_операторов>

или

<пусто>

case <константа2>:

<список_операторов>

или

<пусто>

[default:

<список_операторов>

или

<пусто>]

}

Выражение всегда целочисленное. Константы в метках case всегда целые. По результатам выражения выполняется переход на соответствующую метку case. Если такой метки нету, то переход на метку default. Метка default может отсутствовать. Если метки default нету соответственно case не найден – покидаем switch. Case и default – метки, на них выполняется переход. Как правило, каждая секция операторов для метки case завершается оператором break.

switch(number) {

case 1:

cout<<” число 1”; break;

case 2:

cout<<(2*2); break;

default

cout<<”Ни 1 и не 2”;

}

break – выбрасывает из switch. Если break отсутствует то продолжает выполнятся после выбранного пункта. Например при выборе числа 1 на экране появится 2 сообщения относящихся к case 1 и case 2

19. Операторы в С++. Оператор return.

оператор return

Оператор return завершает выполнение функции и при необходимости указывает её возвращаемое значение.

return [<выражение>];

Оператор return может быть в любом месте функции и при его вызове функция немедленно завершается

int sqr(int x) {

return x*x;

}

void ShowDebug(char*msg, int a)

{

cout<<msg<<a<<endl;

}

В данном случае return не обязателен так как функция ничего не возвращает

int f(int a, int b) {

if (a<0&&b<0)

return 0;

return a*b;

}

20. Виды переменных в С++.

В С++ доступны следующие типы данных:

1) простые типы

2) ссылки

3) указатели

4) массивы

5) структуры и классы

6) битовые поля

Ссылки – синоним переменных. Объявляется с помощью знака &.

int i;

int &a=i;

i=10; (4)

a=20; (5)

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

В примере а – это синоним переменной i.

(4),(5) Обе строки модифицируют одну и ту же ячейку

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

void f(int l, int &k) { //l – передаётся по значению, k – по ссылке

l=l*10;

k=k*10;

}

void m() { //а – не меняется b – будет изменена.

int a=10, b=100;

f(a,b);

cout <<a<<b<<endl;

}

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

21. Ссылки в С++.

Ссылки – синоним переменных. Объявляется с помощью знака &.

int i;

int &a=i;

i=10; (4)

a=20; (5)

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

В примере а – это синоним переменной i.

(4),(5)Обе строки модифицируют одну и ту же ячейку

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

void f(int l, int &k) { //l – передаётся по значению, k – по ссылке

l=l*10;

k=k*10;

}

void m() { //а – не меняется b – будет изменена.

int a=10, b=100;

f(a,b);

cout <<a<<b<<endl;

}

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

Синонимы типов.

Синонимы типов – объявляются с помощью ключевого слова typedef.

Typedef – объявляет не новый тип, это другое название для уже существующего типа.

typedef unsigned int UINT;

unsigned int – беззнаковое целое (тип).

UINT – объявленный пользователем синоним

void f() {

UINT a=10;

unsigned int c=100;

a=c;

}

23. Константы в С++.

Константы.

В теории программирования есть 2 понятия связанные с константами:

 литералы – конкретное значение некоторого типа.

 константы – именованное значение некоторого типа, которое нельзя изменять.

Константы в С++ определяются с помощью ключевого слова const.

const int t=10;

t – константа

10 – значение константы или литерала.

Не Рекомендуется заменять числа именованными константами.

24. Одномерные массивы в С++.

Массив – последовательность однотипных данных, расположенных в смежных ячейках памяти и имеющих один идентификатор.

Над массивами доступны операции индексации – обращение к ячейке по её номеру. В настроенных массивах языка С++ индекс – это целое число от 0 до n-1, где n – количество элементов соответствующей размерности. Начальный индекс только 0.

В С++ нет контроля выхода за границы массива.

1) одномерные массивы

<тип><имя>[<размер>];

void f(){

int arr[10];

for(int i=0; i<10, i++)

cout<<”a[“<<i<<”I==”<<arr[i]<<endl;

}

Массив может иметь начальное значение

int a [3]={1,2,3}; (1)

int b [4]={10,15}; (2)

int c [100] = {0}; (3)

double y[]={4.5,7.6,8.9,10.0}; (4)

(1) массив из 3-х элементов содержащий 3 числа 1,2,3

(2) если инициализирующих литералов не хватает, то оставшиеся ячейки получают значение 0.

(3) массив инициализируется нулями.

(4) размер массива вычисляет компилятор

Особый случай – массивы символов.

25. Многомерные массивы в С++.

Массив – последовательность однотипных данных, расположенных в смежных ячейках памяти и имеющих один идентификатор.

Над массивами доступны операции индексации – обращение к ячейке по её номеру. В настроенных массивах языка С++ индекс – это целое число от 0 до n-1, где n – количество элементов соответствующей размерности. Начальный индекс только 0.

В С++ нет контроля выхода за границы массива.

2) многомерные массивы

Многомерные массивы в С++ это массив массивов.

<тип><имя>[<размер>][<размер2>]…[<размерN>]

int arr[3][4];

Это прямоугольная матрица 3х4.

#include <iostream>

using namespace std;

int main(int argc, char*argv[])

{ const int ROW=S;

const int COLUMN=10;

double matrix [ROW][COLUMN];

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

for(int j=0;j<COLUMN,j++)

cin>>matrix[i][j]; (1)

return 0;}

Для задания размера массива используются константы. В С++ общепринято константы писать с заглавной буквы.

(1) – производится обращение к отдельному элементу массива, но синтаксис позволяет обратиться к отдельной строке

Для одномерных массивов можно задавать начальные значения. Многомерные массивы располагаются в памяти построчно

int a1 [2][3]={{1,-2,2},{3,1,-2}}; // синтаксис использует идею массива массивов

int a2 [][3]= {{1,-2,2},{3,1,-2}}; // одну из размерностей может вычислить компилятор

int a3 [2][3]={1,-2,1,3,1,-2}; // массив располагается в памяти построчно.

int a4 [5][5]={0}; // элементы, значения которых не указаны заполняются нулём (0)

26. Символьные массивы в С++.

В С++ отсутствует поддержка строковых переменных (переменных, содержащих текст). Для представления строк в программах на С++ используются массивы переменных типа char. Например, вы можете выполнить следующее присваивание:

char text[] = "This is a string.";

Это приведет к выделению 18 байт памяти для хранения строки. Однако, как вы могли заметить, в данной строке всего 17 символов. Причина выделения 18 байт состоит в том, что каждая строка завершается нуль-символом, и С++ учитывает его при размещении массива в памяти.

Нуль-символ (terminating null) - это специальный символ, представляемый в программах как \0, эквивалентный числу 0.

Когда программа встречает в символьном массиве 0, она интерпретирует его как конец строки.

27. Указатели в С++. Понятие указателя.

Указатель – переменная, значением которой является адрес ячейки памяти

Память программы – последовательность байтов, каждый из которых имеет свой номер (адрес).

Когда переменная размещается в памяти, она занимает несколько байтов.

Адрес переменной – адрес начального байта.

Указатель хранит число – адрес начального байта.

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

Кроме указателя на данные С++ поддерживает указатели на код:

указатель на функции

int *a; // указатель на целое

int *b, *c // отделение двух указателей в одной строке

char *l; // указатель на другие типы

double *d; // указатель на другие типы

int *m=0; // указатель проинициализирован нулём

void *P; // указатель на void

int **pi; // указатель на указатель (двойной указатель)

В языке программирования С++ указатель который никуда не указывает (пустой указатель) хранит 0. Запись 0 указателя – стандартный приём в синтаксисе С++.

В языке С пустой указатель обозначается константой NULL.

Указатель на void – не типизированный указатель.

Память программы – однородный массив байтов. То, как обрабатываются байты, определяется алгоритмом программы.

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

28. Указатели в С++. Операции над указателями.

1) & взятие адреса.

2) * разыменование (получить значение по адресу)

3) = присваивание

4) ++ инкремент (перейти к следующему элементу массива)

5) -- декремент (перейти к предыдущему элементу массива)

6) + увеличивает указатель на целое значение

7) += увеличить с присваиванием

8) - уменьшить указатель на целое значение. Получить разность указателей.

9) -= уменьшить указатель на целую величину

10) ==,!=,<,>,<=,>= сравнение адресов

11) new - выделение памяти

12) delete - освобождение памяти

void f()

{

int a=5;

int *p=0; (1)

cout<<a<<endl;

cout<<(&a)<<endl; (2)

p=&a; (3)

cout<<p<<endl; (2)

cout<<(*p)<<endl; (4)

*p=10; (5)

cout<<(*p)<<endl;

}

(1) – указатель объявлен как локальная переменная.

Без начальной инициализации указатель указывает непонятно куда. Поэтому присваивается 0;

(2) – выводят на экран одинаковые значения. Т.к. в строчке (3) присваивается значение адреса а (&a);

(4) – получаем значение ячейки, на которую ссылается указатель.

(5) – записать значение в ячейку, на которую ссылается указатель.

29. Указатели в С++. Указатели и массивы.

С точки зрения С++ имя массива – это константный указатель на участок памяти.

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

Индексация массива – сложение указателя с целым числом.

int arr[10];

0 1 2 3 4 5 6 7 8

arr – константа, её значение нельзя изменить.

arr указывает на начальную ячейку (0)

int *p=arr; (1)

p=p+3; (2)

*p=1000; (3)

p=p-1; (4)

l=p+3; (5)

*l=100; (6)

cout<<((arr+5)==l)<<endl; (7)

cout<<(l-p)<<endl; (8)

*(arr+3)->arr[3]; (9)

(1) p - указатель на целое, его можно проинициализировать значением констант arr

Указатель можно складывать с целым числом, это производит сдвиг на соответствующее количество элементов в массиве

(4) Вычитание из указателя целого числа n – это сдвиг на n элементов в сторону уменьшения индекса

(5) Использование промежуточной переменной в виде указателя.

(7) Выведет на экран 1 (true) (arr+5) – вычисляет адрес 5 элемента массива.

(8) Возвращает число элементов массива которое размещается между двумя указателями. (на экране появится 3)

(9) Индексация в С++

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

30. Указатели в С++. Операции new и delete.

new - выделение памяти

delete - освобождение памяти

Синтаксис:

<указатель>=new<тип>; (1)

<указатель>=new<тип>(<значение>); (2)

delete <указатель>; (3)

(1) Выделяют в динамической памяти блок байтов для хранения значений типов; адрес блока записывается в указатель

(2) Блок инициализируется начальным значением.

(3) Освобождает блок памяти, на который ссылается указатель.

При вызове delete блок памяти освобождается, но не удаляется; указатель становится некорректным. Delete для пустого указателя обрабатывается корректно. Не производит никаких действий. В С++ предполагается «ручное» управление памятью. Другие языки могут использовать автоматическое управление памятью (сборщик мусора).

new и delete позволяют управлять блоками памяти, содержащими по несколько элементов одного типа.

<указатель>=new<тип>[<размер>];

delete[]<указатель>;

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

31. Указатели в С++. Указатели и динамические массивы.

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

Приведённый код – пример работы с динамическим массивом (размер которого заранее неизвестен). Особенности:

1) компилятор не контролирует выход за границы диапазона;

2) изменить размер массива в процессе работы программы можно только через его пересоздание.

Динамический массив с изменяемым размером реализуется с помощью шаблонов.

32. Функции в С++. Определение функции.

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

Определить ф-ю – значит задать способ выполнения операции.

Прототип ф-и выглядит так:

<тип> <имя>(<список параметров>);

Если объявлен прототип, то ф-ю можно вызывать.

33. Функции в С++. Вызов функции.

Вызов ф-и реализуется в виде выражения:

<тип> <имя> (<список параметров>)

{

<операторы>

}

<имя>(<список параметров>)

При вызове указываются фактические параметры. Формальные параметры – это те, которые указаны в прототипе и определении.

34. Функции в С++. Область видимости.

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

1) глобальные - объявлены за пределами функций без модификатора static. Время жизни – всё время работы программы. Область видимости – вся программа, если используется описание extern. Если не используется описание extern то глобальная переменная видима от точки своего определения до конца файла (модуля)

2) локальные – определены внутри функции без модификатора static. Может быть определена в любом месте функций, где допустим оператор. Область видимости от точки определения, до конца соответствующего блока кода. Время жизни – от момента прохождения потока управления через точку определения, до момента завершения соответствующего блока кода.

3) статические переменные модулей –определены с ключевым словом static за переделом функции. Доступна только в данном модуле. Время жизни – всё время работы программы. Область видимости – от точки определения до конца модуля (файла)

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

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

35. Функции в С++. Передача параметров.

Параметры в ф-ю можно передать:

1) по значению – значение копируется в формальный параметр ф-и

void f(int a){

cout<<a<<endl;

a=100;

}

void k(){

int c=50;

f(c);

cout<<c<<endl;

}

2) по ссылке – изменение формального параметра меняет переданную переменную

void f(int &a){

cout<<a<<endl;

a=100;

}

void k(){

int c=50;

f(c);

cout<<c<<endl;

}

3) через указатель – в ф-ю передаётся адрес памяти, где хранится значение для обработки. Этот способ используется для передачи в ф-ю массивов. Ф-и работают с массивами только через указатель. Нет явного способа передать или получить массив.

void f(int *a){

cout<<(*a)<<endl;

*a=100;

}

void k(){

int c=50;

f(&c);

cout<<c<<endl;

}

36. Функции в С++. Параметры по умолчанию.

Сущ. способ обеспечить вызов ф-и с меньшим числом параметров, чем описано в прототипе или определении.

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

void m(int a1, int a2=10, int a3=4, int a4=100);

void n() {

m(36, 15, 4, 120);

m(36, 10, 6);

}

37. Функции в С++. Встраиваемые функции.

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

inline int sqr(int x){

return x*x;}

void m(){

{

cout<<sqr(10)<<endl;

cout<<sqr(100)<<endl;

}

Если алгоритм ф-и сложный, то встраивание может не дать преимущества.

Встраивать или нет – решает компилятор. Для inline-функции нельзя определить прототип.

38. 1. Функции в С++. Перегрузка функций.

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

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

void print(char*);

void print(int);

void print(int, int);

\\Имя одно, типы и количества разные.

void f()

{

print(“Test”);

print(20);

print(20,16);

}

Компилятор С++ для поиска нужной ф-и использует следующее правило:

1) сначала ищется функция с прямым соответствием набору типов

2) затем поиск ведётся для стандартных преобразований типов

3) затем поиск осуществляется с учётом иерархии классов

4) затем поиск осуществляется с учётом преобразования типов определяемых пользователем.

5) затем поиск осуществляется с учётом неопределённого количества аргументов.

int sqr(int x)

{

return x*x;

}

long double sqr(long double x)

{

return x*x;

}

void m()

{

short a=10;

sqr(a);

double d=10.3;

sqr(d);

}

Также стандартным преобразованием типов является обработка указателей на void.

Неуказанное (переменное) количество аргументов необходимо для функций ввода/вывода. Это функции printf и scanf:

int printf(char*format, …);

int scanf(char*format, …);

В прототипах «…» - любая комбинация аргументов. Но, для того, чтобы обработать свои аргументы функция обязательно должна знать их количество. Такие функции обычно используют определённые соглашения, чтобы вычислить число аргументов. Эти соглашения не может проверить компилятор. Рекомендуется использовать такие функции как можно реже.

Рассмотрим пример функции с неуказанным числом аргументов: функция, которая выводит сообщение об ошибке; первый аргумент – целое число (серьёзность ошибки), далее идут строки в любом количестве. Список аргументов завершается нулевым указателем

void error (int severity, …);

38.2. Функции в С++. Перегрузка функций.

int main(int argc, char*argv[])

{

switch (argc);

{

case 1:

error(0,argv[0],0);

break;

case 2:

error(0,argv[0],argv[1],0);

break;

default;

char buffer[100]={0};

error(0,”argc= “, itoa(argc,buffer),0);

}

return 0;

}

В примере используются аргументы функции main – параметры командной строки консольного приложения; массив argv содержит хотя бы 1 элемент. argv[0] – полный путь к исполняемому файлу.

Функция itoa – преобразование целого в строку. Ей всегда нужен дополнительный выход.

#include “stdarg.h”

void error(int severity, …)

{

va_list (ap);

va_start (ap,&severity);

for(;;);

{

char*p= va_arg (ap,char*);

if(p==0)

break;

cout<<p<<’ ‘;

}

va_end(ap);

cout<<endl;

if(severity)

exit(severity);

}

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

39. Функции в С++. Передача массивов в функции.

Массив в ф-ю передаётся всегда по указателям. Без особых ухищрений нельзя передать массив по значению. Массив всегда передаётся по ссылке. В С++ в большинстве случаев невозможно вычислить размер переданного массива. Как правило, вместе с массивом передаётся и его размер. Речь идёт об одномерных массивах.

void f(const int n, int array[]) {

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

array[i]=rand();

}

void l() {

const int SIZE=10;

int a[SIZE];

f(SIZE, a);

}

Многомерный массив передаётся похожим образом, но переменной может быть только одна размерность, остальные задаются константами.

cons tint COL=10;

void show (int row, int arr[][COL]) {

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

for (int j=0; j<COL; j++)

cout<<arr[i][j]<<endl;

}

void f() {

int n[10][COL];

show(10, n);

}

Массив невозможно вернуть в качестве значения ф-и, т.к. необходимо возвращать 2 значения: сам массив и его размер. За исключением случая, когда размер массива – константа. Но необходимо следить за выделением памяти. Есть хитрость, которая позволяет передать и вернуть массив по значению: массив можно сделать полем в структуре или классе. По умолчанию компилятор копирует поля структур и классов при передаче их ф-и и обратно.

struct A{

int arr[10][20];

};

void show (A n){

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

for (int j=0; j<20; j++)

cout<<n.arr[i][j]<<endl;

}

void f() {

A m;

show(m);

}

Как правило, вместо стандартных массивов используется шаблон vector из стандартной библиотеки шаблонов.

Поиск по сайту: