40гг первые цифровые компьютеры программирование путем коммутации проводов

Вид материала

Документы

Содержание

Класс памяти
Бинарные операции
Присваивание адреса в явном виде
Связь массивов и указателей
Динамические массивы

Подобный материал:

1 2 3 4 5 6 7 8 9 ... 12

тип_возвращаемого_значения имя ([параметры ])

{

операторы, составляющие тело функции

}

Если функция не должна возвращать значение, указывается тип void.
Тело функции заключается в фигурные
скобки;
Функции не могут быть вложенными;

Описание переменной

[класс памяти] [const] тип имя [инициализатор];

Необязательный класс памяти может принимать одно из значений auto, extern, static и register.
Модификатор const показывает, что значение переменной изменять нельзя. Такую переменную называют именованной константой, или просто константой.
При описании можно присвоить переменной начальное значение, это называется инициализацией. Инициализатор можно записывать в двух формах

со знаком равенства: = значение
в круглых скобках: ( значение )

Константа должна быть инициализирована при объявлении.
В одном операторе можно описать несколько переменных одного типа, разделяя их запятыми.

Примеры описания переменных

short int а = 1:

const char С = ‘С’;

char s, sf = 'f’;

char t (54);

float с = 0.22, x(3), sum;

Область действия идентификатора

Другое название – область видимость переменной
Область действия идентификатора - это часть программы, в которой его можно использовать для доступа к связанной с ним области памяти.
Если переменная определена внутри блока она называется локальной, область ее действия — от точки описания до конца блока, включая все вложенные блоки.
Если переменная определена вне любого блока, она называется глобальной и областью ее действия считается файл, в котором она определена, от точки описания до его конца.

Класс памяти

auto — автоматическая переменная. Память под нее выделяется при необходимости и инициализируется каждый раз при выполнении оператора, содержащего ее определение. Освобождение памяти происходит при выходе из блока, в котором описана переменная. Время ее жизни — с момента описания до конца блока.
extern — означает, что переменная определяется в другом месте программы (в другом файле или дальше по тексту).
static — статическая переменная. Время жизни — постоянное. Инициализируется один раз при первом выполнении оператора, содержащего определение переменной.
register — аналогично auto, но память выделяется по возможности в регистрах процессора. Если такой возможности у компилятора нет, переменные обрабатываются как auto.

Этапы создания исполняемой программы

С++. Базовые средства описания действий

Основные вопросы

Операции
Выражения
Операторы ветвления
Операторы цикла
Операторы передачи управления

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

++

--

sizeof

~

!

-

&

*

new

delete

(type)

увеличение на 1

уменьшение на 1

размер a=sizeof(float) à a=4;

поразрядное отрицание

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

арифметическое отрицание (унарный минус)

получение адреса

разыменование указателя

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

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

преобразование типа

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

* / %

+ -

<< >>

< > <= >=

= = !=

& |

&& ||

=

*= /=

%=

+= -=

<<= >>=

&= |=

=

Тернарная операция

? :
a=(b>c)?b:c

#include

int main(){

int a = 11, b = 4, max;

max = (b > a)? b : a;

printf("Наибольшее число: %i", max);

return 0;

}

Выражения

Выражения состоят из операндов, знаков операций и скобок и используются для вычисления некоторого значения определенного типа
Каждый операнд является:

выражением
константой
переменной.

Примеры выражений

(а + 0.12)/6
х && у || !z
(t * sin(x)-1.05e4)/((2 * k + 2) * (2 * k + 3))

Приоритеты операций

Операции выполняются в соответствии с приоритетами.
Для изменения порядка выполнения операций используются круглые скобки.
Если в одном выражении записано несколько операций одинакового приоритета, унарные операции, условная операция и операции присваивания выполняются справа налево, остальные — слева направо.
Например:

а = b = с означает а = (b=с),
а + b + с означает (а + Ь) + с.

Порядок вычисления подвыражений внутри выражений не определен.
Например, нельзя считать, что в выражении (sin(x + 2) + cos(у + 1)) обращение к синусу будет выполнено раньше, чем к косинусу, и что х + 2 будет вычислено раньше, чем y+1.

Операторы ветвления

Оператор if
Оператор switch

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

Условный оператор if используется для разветвления процесса вычислений на два направления.
Формат оператора:

if ( выражение ) оператор_1; [else оператор_2;]

Сначала вычисляется выражение, которое может иметь арифметический тип или тип указателя.
Если оно не равно нулю (имеет значение true), выполняется первый оператор, иначе — второй.
После этого управление передается на оператор, следующий за условным.

Примеры условного оператора (1)

if(a<0)

b = 1;

if(ad || a==0))

b++;

else

{

b*=a;

a = 0;

}

Примеры условного оператора (2)

if(a

{

if(a

m = a;

else

m = c;

}

else

{

if(b

m = b;

else

m = c;

}

Оператор switch

Оператор switch (переключатель) предназначен для разветвления процесса вычислений на несколько направлений.

Формат оператора:

switch(выражение){

case константное_выражение_1: [список_операторов_1]

case константное_выражение_2: [список_операторов_2]

…

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

[default: операторы ]

}

Пример использования switch

#include int main(){

int a,b,res;

char op;

cout « "\пВведите 1й операнд : ”; cin » a;

cout « "\пВведите знак операции : ”; cin » op;

cout « "Введите 2й операнд : “ cin » b;

bool f = true;

switch (op){

case ‘+’ : res = a+b; break;

case ‘-’ : res = a-b; break;

case ‘/’ : res = a/b; break;

case ‘*’ : res = a*b; break;

default: cout « “Неизвестная операция"; f=false;

}

if (f) cout « “Результат : “ << res;

return 0;

}

Операторы цикла

Цикл с предусловием (while)

Цикл с постусловием (do while)

Цикл с параметром (for)

Цикл с предусловием (while)

Цикл с предусловием имеет вид:

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

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

Выполнение оператора начинается с вычисления выражения.

Если оно истинно (не равно false), выполняется оператор цикла.

Если при первой проверке выражение равно false, цикл не выполнится ни разу.

Выражение вычисляется перед каждой итерацией цикла.

Пример цикла while

#include

int main(){

int num;

cout « "Введите число : ";

cin » num;

int half = num / 2; // половина числа

int div = 2; // кандидат на делитель

while (div <= half){

if(!(num % div))

cout « div <<"\n”;

div++;

}

return 0;

}

Цикл с постусловием (do while)

Цикл с постусловием имеет вид:

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

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

Вычисляется выражение.

Если оно истинно (не равно f al se), тело цикла выполняется еще раз.

Цикл завершается, когда выражение станет равным false.

Пример использования
do … while

#include

int main(){

char answer;

do{

cout « "\пКупи слоника! ";

cin » answer;

}while (answer != 'y');

return 0;

}

Цикл с параметром (for)

Цикл с параметром имеет следующий формат:

for (инициализация; выражение; модификации) оператор;

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

Выражение определяет условие выполнения цикла: если его результат равен true, цикл выполняется. Цикл с параметром реализован как цикл с предусловием.

Модификации выполняются после каждой итерации цикла и служат обычно для изменения параметров цикла.

Простой или составной оператор представляет собой тело цикла.

Любая из частей оператора for может быть опущена (но точки с запятой надо оставить на своих местах!).

Пример цикла for

#include

int main(){

int num;

cout « "Введите число : ": cin » num:

for (int half=num/2,div=2;div<=half;div++)

if (!(num % div))

cout« div <<"\n“;

return 0;

}

Операторы передачи управления

оператор безусловного перехода goto;

оператор выхода из цикла break;

оператор перехода к следующей итерации цикла continue;

оператор возврата из функции return.

Оператор goto

Оператор безусловного перехода goto имеет формат:

goto метка;

В теле той же функции должна присутствовать ровно одна конструкция вида:

метка: оператор;

Оператор goto передает управление на помеченный оператор.

Метка — это обычный идентификатор, областью видимости которого является функция, в теле которой он задан.

Оператор break

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

Пример использования
break

#include

int main(){

char answer;

while(true){

cout « "\пКупи слоника! ";

cin » answer;

if(answer == ‘y’)

break;

}

return 0;

}

Оператор continue

Оператор перехода к следующей итерации цикла continue пропускает все операторы, оставшиеся до конца тела цикла, и передает управление на начало следующей итерации.

Пример использования
continue

#include

int main(){

int num;

cout « "Введите число : ": cin » num:

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

if(i%2)

continue;

cout« i <<"\n“;

}

return 0;

}

Оператор return

Оператор возврата из функции return завершает выполнение функции и передает управление в точку ее вызова. Вид оператора:

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

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

Пример оператора return

int max(int a, int b){

if(a>b)

return a;

else

return b;

}

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

Основные вопросы

Понятие указателя

Инициализация указателей

Операции с указателями

Ссылки

Массивы

Строки

Имя и адрес переменной

Запись в программе:

int i = 10;

Понятие указателя

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

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

Указатель на объект данных

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

Указатель на область памяти (void)

Переменные – указатели подчиняются общим правилам области видимости и времени жизни переменных

Указатель на объект данных

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

Объявление указателя: тип *имя;

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

Звездочка в объявлении относится непосредственно к имени переменной, поэтому для объявления нескольких указателей необходимо ставить звездочку перед каждым именем - int *a, b, *c;

В Windows размер указателя – 4 байта.

Можно определить указатель на указатель и т.д.

int **p;

Размещение указателей в памяти

Запись в программе:

int i = 10;

int *p = &i;

int **pp = &p;

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

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

Указатели на функции используются для

косвенного вызова функции

передачи функции в качестве параметра другой функции

Имеет тип «указатель на функцию, возвращающую значение заданного типа и имеющие аргументы заданного типа»

тип (*имя) (список типов аргументов)

Например: int (*fun)(double, double)

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

bool (*eq)(double,double);

bool eqSharp(double a,double b){

if(abs(a-b) < 0.000000001)

return true;

else

return false;

}

bool eqApp(double a,double b){

if(abs(a-b) < 0.1)

return true;

else

return false;

}

int main(){

double x,y;

…

if(…)

eq = eqSharp;

else

eq = eqApp;

if(eq(x,y))

…

…

}

Указатель на область памяти (void)

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

Можно присвоить значение указателя любого типа.

Можно сравнивать с указателями любых типов.

Указатели и константы

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

int i; // переменная

const int ci; // константа

int *pi; // указатель на переменную

const int * pci; // указатель на константу

int * const cp = &i; // Указатель-константа на переменную

const int * const cpc = &ci; //Указ.-конст. на константу

Инициализация указателей

Присваивание указателю адреса существующего объекта

Присваивание адреса в явном виде

Присваивание пустого значения

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

Присваивание указателю адреса существующего объекта

С помощью операции получения адреса

nt a; // переменная

int *p = &a; // в указатель записывается адрес a

int *pp(&a); // инициализация другим способом

С помощью значения другого указателя

int *r = p;

C помощью имени массива или функции

int b[10]; // массив

int *t = b; // присваивание адреса начала массива

…

void f(int a){…} // определение функции

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

pf = f; // присваивание адреса функции

Присваивание адреса в явном виде

char *vp = (char *)0xb8000000;

Присваивание пустого значения

int * x = NU;

int *y = LL0;

Гарантируется, что объектов с нулевым адресом существовать не может.

Нулевое значение удобно использовать когда указатель не связан с объектом.

Динамическая память

Динамическая память (куча, heap) – память, в которой можно выделять место во время работы программы в соответствии с потребностями.

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

Выделенная память сохраняется до завершения программы или до ее явного освобождения.

Для выделения памяти используются функция malloc и операция new.

Для освобождения памяти – функция free и операция delete.

Выделение и освобождение динамической памяти

Выделение памяти

int * p1 = new int;

int * p2 = new int (10);

int *p3 = new int[10];

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

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

delete p1;

delete p2;

delete [ ] p3;

Операции с указателями

разадресация (разыменование)

присваивание

сложение с константой, вычитание константы

инкремент и декремент

сравнение

приведение типа

Разыменование

Обозначается звездочкой «*»

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

Не допускается с адресами типа void

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

Примеры использования:

char a; // переменная

char *p = new char; // Выделение динамической памяти

*p = ‘Ю’ ; a = *p; // присваивание значений

Арифметические операции

Автоматически учитывают тип указателя.

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

char *p1 = (char *)0xAABBCC00;

char * pn = p1 + 1; // pn = 0xAABBCC01;

int *p2 = (int *)0xAABBDD00;

int *pm = p2 + 1; // pm = 0xAABBDD04;

Сложение указателей не допускается

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

Ссылки

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

Объявление ссылки: тип & имя;

Переменная-ссылка должна явно инициализироваться при описании. Кроме случаев:

ссылка является параметром функции

ссылка описана как extern;

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

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

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

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

Пример использования ссылки

int kol = 5;

int & pal = kol; //pal – альтернативное имя для kol

pal ++; // kol = 6;

Массивы

Описание одномерного массива –

тип имя[количество];

Элементы массива нумеруются с нуля.

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

Класс памяти

const

инициализатор (инициализирующие значения записываются в фигурных скобках)

Размещение массива производится на этапе компиляции, поэтому количество элементов должно быть константой.

Количество элементов предпочтительнее задавать с помощью именованных констант поскольку при таком подходе для его изменения достаточно скорректировать значение константы всего лишь в одном месте программы.

Примеры массивов

int m[10];

int N = 100;

double dm[N];

long array[5] = {1,2,3,4,5};

int mas[] = {3,2,1};

int mm[100] = {1,2,3};

Доступ к элементам массивов

Для доступа к элементу массива после его имени указывается номер элемента (индекс) в квадратных скобках.

Например:

int k = mas[i];

Работа с массивом

#include

int main(){

const int n = 10;

int i, sum;

marks[n] = {3, 4, 5, 4, 4};

for (i = 0, sum =0; i
sum += marks[i];

cout « "Сумма элементов:” « sum;

return 0;

}

Связь массивов и указателей

Идентификатор массива является константным указателем на его нулевой элемент.

int b[10] –

b и &b[0] – означают одно и то же.

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

Работа с массивом через указатель

Фрагмент программы копирует массив а в массив b.

int a[100], b[100];

int *ра = а;

int *pb = b;

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

*pb++ = *pa++;

Динамические массивы

Blog

40гг первые цифровые компьютеры программирование путем коммутации проводов

Содержание