C++

main()
{
print();
}
int print()
{
printf("Hi!");
return 1;
}

Как стало

в С++:

#include
using namespace std;

int print(); // Обязательно!!!

void main()
{
print();
}
int print()
{
cout<<"Hi!";
return 1;
}

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

не void могла вернуть неопределенное значение

int a() {
return ”

”;
}

Как стало в С++:

Для функции типа не void оператор return внутри этой функции должен содержать значение указанного типа

#include "iostream"

using namespace std;
int print();

void main()
{
print();
}

int print()
{
return "Hi!";
}

void main()
{
int i,k=0;
for (i=0; i

k+=i;
}

Как стало в С++:

#include
using namespace std;

void main()
{
int i;
for (i=0; i<10; i++)
cout< int k=0;
k+=i;
}

В С++ локальные переменные могут быть объявлены в любом месте программы, а не только в начале блока, как это было в языке С.

main()
{
printf(”Example\n”);
getch();
}
Как стало в С++:
#include
using namespace std;

void main()
{
char buf[10];
cout

С++ консольный ввод вывод реализован также как и в С на основе стандартных потоков ввода/вывода (stdin/stdout в С) cin и cout в С++ и при помощи перегруженных операторов поразрядного сдвига << и >>

print();
int array[10];
void main()
{
input(); print();
}

int input()
{
for (int

i=0; i<10; cin>>array[i],i++);
return 0;
}

int print()
{
for (int i=9; i>-1; cout< cout< return 0;
}

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

равный приоритет и при размещении рядом выполняются справа налево.
Ваша

заготовка для экзамена…

int x[4]= {0,2,4,6}, *p, n;
p = &x[0]; // p равно адресу первого элемента массива x
n = *p; // n равно 0, p равно &x[0]
n = *p++; // n равно 0, p равно &x[1],т.к. x[1]=2
n = ++*p; // n равно 3, p равно &x[1],т.к. x[1]=2
n = *++p; // n равно 4, p равно &x[2],т.к. x[2]=4
n = (*p)++; // n равно 4, p равно &x[2], x[2]=5
n = ++(*p); // n равно 6, p равно &x[2], x[2]=6

( function overloading) позволяет определять несколько функций с одним и

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

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

int n2);

void main()
{
print(); print(1); print(2,3);
}

void print() {

cout << "Nothing " << endl; }
void print(int n1) { cout << "N1 = " << n1 << endl; }
void print(int n1, int n2) { cout << "N1 + N2 = " << n1+n2 << endl; }

Результат выполнения программы:

Если в этот пример добавить функцию с прототипом, например, таким void print(int n1, int n2); ,то компилятор выработает синтаксическую ошибку, поскольку тело функции print(int , int ); уже определено.

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

вызове функции

Пример
#include "iostream“
using namespace std;
void add(int a=0, int b=0, int c=0);

void main()
{
add(); add(1); add(2,3); add(2,3,4);
}
void add(int a, int b, int c) { cout << a+b+c << endl; }

Реализация такого механизма обеспечивается синтаксисом:
возвращаемый_тип имя_функции (тип_аргумента=значение, …);
int func (int a=0, int b=2, int c=7);
Данный синтаксис напоминает инициализацию переменных.

Результат выполнения программы:

Из примера видно, что нельзя задать значение по умолчанию аргументу a и присвоить какое-нибудь значение аргументу b.

a, int b, int c);

void main()
{
add(); add(1);

add(2,3); add(2,3,4);
}

void add(int a=0, int b=0, int c=0) { cout << a+b+c << endl; }

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

error C2660: 'add' : function does not take 0 arguments
error C2660: 'add' : function does not take 1 arguments
error C2660: 'add' : function does not take 2 arguments

c);
void add(int a, int b=100);

void main()
{
add(2,3); add(1);
}
void add(int

a, int b) { cout << a+b << endl; }
void add(int c) { cout << c << endl; }

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

1>.\bsuir1.cpp(8) : error C2668: 'add' : ambiguous call to overloaded function
1> .\bsuir1.cpp(4): could be 'void add(int,int)'
1> .\bsuir1.cpp(3): or 'void add(int)'
1> while trying to match the argument list '(int)’

() { return X; }
inline void Set (int x=0) {X

= x; }
};
…
Cl Obj;
Obj.Set (Obj.Get()+1);

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

Function calls (including parameter passing and placing the object's address on the stack)
Preservation of caller's stack frame
New stack-frame setup
Return-value communication
Old stack-frame restore
Return

inline функции не генерируются компилятором:
1) если в ней присутствуют циклы,
переключатели, переходы;
2) если она рекурсивна;
3) если в ней содержатся статические
переменные

Глобальная переменная
void func()
{
int i=1; // Локальная переменная
::i++;

i++;
cout << "G = " << ::i << endl;
cout << "L = " << i << endl;
};
void main() { func(); }

Переменные можно объявлять в любом месте программы.
При объявлении переменных им можно задавать конкретные инициализирующие значения. Такое свойство языка программирования называется динамической инициализацией.
В программах могут возникать ситуации, когда имя глобальной переменной совпадает с именем локальной, объявленной внутри функции или блока. Для того, чтобы получить доступ из блока, где объявлена локальная переменная, к глобальной переменной с таким же именем, в С++ применяется оператор «области видимости» (scope resolution operator) – “::”.

Результат выполнения программы:

cout

endl;
};

void main() { func(); func(); func(); }

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

Результат выполнения программы:

используются операторы new и delete.
Динамическая память – поставляемый системой пул

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

Оператор new определяется как new имя типа / new (имя типа)
но может иметь форму с инициализацией: new имя типа инициализатор

Сначала – распределяется объем, достаточный для того, чтобы содержать указанный тип данных. Затем базовый адрес объекта возвращается как значение выражения new .
Если выделить память не удается – возвращается 0.
Инициализатор – это обычно список параметров для конструктора создаваемого объекта.
Нельзя использовать его для инициализации массивов

Примеры:

int *Num = new int;
double (*pVal) = new double;
char (*pArr)[10] = new char[sz][10]; // sz на 10 байт
int (**p) () = new (int (*[7]) ()); // массив из 7 указателей
// на функции, возвращающих целое значение

выражение
или delete [ ] выражение
Выражение – это обычно

переменная-указатель, которая была использована в операторе new.

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

Примеры:

int *Num = new int;
delete Num;
double (*pVal) = new double;
delete pVal;
char (*pArr)[10] = new char[sz][10]; // sz на 10 байт
delete [] pArr;
int (**p) () = new (int (*[7]) ()); // массив из 7 указателей
// на функции, возвращающих целое значение
delete [] p;

передаются либо при помощи ссылки (by reference) либо по значению

(by value) .

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

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

по ссылке. Ссылка (неявный указатель) – это по существу еще

одно имя объекта.
3 варианта организации параметров:
по значению
int fun_a1(int a); // описание
fun_a1(i); // обращение
int x = a; // использование
по указателю
int fun_a2(int* a); // описание
fun_a2(&i); // обращение
int x = *a; // использование
по ссылке
int fun_a3(int& a); // описание
fun_a3(i); // обращение
int x = a; // использование

Ссылки – передача аргументов

std;
int x;
int &F() {return x;}

void main()
{
F() = 0xff;
}
Функция F()

возвращает ссылку на переменную целого типа.
Необходимо отметить, что оператор return в функции F() возвращает не значение глобальной переменной x, а ссылку (адрес) этой переменной.
Дальнейшее действие компилятор воспринимает как занесение по адресу переменной x значения 0xff.

static int n=5;
cout

<< endl;
return n;
}

void main()
{
int &ref = F();
cout << "ref = " << ref << endl;
ref++;
ref = F();
cout << "ref = " << ref << endl;
}

Результат выполнения программы:

Ссылка также может быть использована как дубликат какой-либо переменной:

int n=10;
int &ref=n;
ref++;

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

процедуру приведения типов.

. . .
int *ptr;
int X =4;
ptr = &X;
double d=0.5, *pd;

//pd = ptr; // error C2440: '=' : cannot convert from 'int *' to 'double *‘

pd = (double*) ptr;

//2

b++; //3

b--;

//4

Дан фрагмент кода:

//2

b++; //3

b--;

//4

Дан фрагмент кода:

Ошибка в строке 2: первый оператор "++" сработает и вернет (как положено постфиксному оператору) rvalue, а применять к rvalue оператор "++" (любой - постфиксный или префиксный) нельзя. Т.е. ошибка здесь возникает именно из-за наличия второго оператора инкремента.
Ошибка в строке 4: нельзя применять оператор "--" (как префиксный, так и постфиксный) к переменной типа bool.

программы:


int i = 6;
i = 7,i++,i++;
Варианты ответа:


6

7
8
9
Значение не определено

программы:


int i = 6;
i = 7,i++,i++;
Варианты ответа:


6

7
8
9
Значение не определено

n, а затем корректно очищают выделенную под него память?


int *array

= new int[n];
delete array[];

int *array = new int[n];
delete array;

int array[n];
delete array;

int* array = new int[n];
delete[n] array;

int *array = new int[n];
delete[] array;

n, а затем корректно очищают выделенную под него память?


int *array

= new int[n];
delete array[];

int *array = new int[n];
delete array;

int array[n];
delete array;

int* array = new int[n];
delete[n] array;

int *array = new int[n];
delete[] array;

// 1

int *p2 = 1;

// 2

double *p3 = 1.0L; // 3

char *p3 = '\0'; // 4

Дан фрагмент кода:

// 1

int *p2 = 1;

// 2

double *p3 = 1.0L; // 3

char *p3 = '\0'; // 4

Дан фрагмент кода:

Cтрока 2 содержит ошибку, т.к. указателю нельзя присваивать целое число, отличное от нуля.

Cтрока 3 содержит ошибку, т.к. указателю нельзя присваивать число с плавающей точкой.