Inline int even (int X)
{
return !(x%2);
}
main()
{
int val;
cin >> val;
if (even(val)) cout << val << “ является четным”;
if (even(val)) cout << val <<” является нечетным”;
return 0;
}
Здесь функция even(), которая возвращает 1 при четном аргументе, объявлена как inline-функция. Это означает, что строка
if (even(val)) cout << val << “ является четным”;
функционально идентична строке
if (!(x%2)) cout << val << “ является четным”;
Этот пример демонстрирует еще одну важную особенность inline-функции – она должна быть задана до ее первого вызова. Если это не так, компилятор не будет знать, что именно предполагается встроить в программу на место вызова функции.
Спецификатор inline является запросом, а не командой для компилятора. Если компилятор не в состоянии выполнить запрос, он будет проигнорирован, и функция будет компилироваться, как обычная функция.
В зависимости от типа компилятора существуют некоторые ограничения на содержимое встраиваемых функций. Так, некоторые компиляторы не воспринимают функцию как inline, если она содержит статические переменные, оператор цикла, операторы switch или goto, или если функция является рекурсивной.
Допускается также перегружать встраиваемую функцию. Например, программа, перегружающая функцию min() тремя способами:
#include<iostream.h>
//целые аргументы
Inline int min(int a, int b)
{
return a<b ? a : b;
}
//длинные аргументы
Inline long min(long a, long b)
{
return a<b ? a : b;
}
//аргументы двойной точности
Inline double min(double a, double b)
{
return a<b ? a : b;
}
main()
{
cout << min (-10,10) << “\n”;
cout << min (-10.01,10.01) << “\n”;
cout << min (-10L,10L) << “\n”;
return 0;
}
В С для выделения динамической памяти используется функция malloc(), а для освобождения – free(). Вместо этих функций в С++ стал применяться более безопасный способ выделения и освобождения памяти – использование операторов new и delete. Общий вид этих операторов:
p_var=new type;
delete p_var;
Здесь type – это спецификатор типа объекта, для которого нужно выделить память, а p_var – указатель на этот тип. New – это оператор, который возвращает указатель на динамически выделяемую память, достаточную для хранения объекта типа type. Оператор delete освобождает эту память, когда в ней отпадает необходимость.
Если свободной памяти недостаточно для выполнения запроса, также, как и в С, new возвращает нулевой указатель. Аналогично, delete выполняется только с указателем на предварительно выделенную с помощью new память. В противном случае возникает ошибка, которая может привести к прекращению выполнения программы.
Новый способ управления памятью имеет преимущества перед старым механизмом.
new автоматически выделяет требуемое для хранения объекта заданного типа количество памяти. Отпадает необходимость использования sizeof для подсчета количества байтов, что уменьшает вероятность ошибок.
new автоматически возвращает указатель на заданный тип, и больше не нужно использовать приведение типов, как при использовании malloc().
new и delete можно перегружать, что дает возможность реализации собственной модели распределения памяти.
имеется возможность инициализации объекта, для которого динамически выделена память.
// использование new и delete
#include<iostream.h>
main()
{
int *p;
p= new int; //память для целого
//нужно убедиться, что память выделена
if (!p)
{
cout << “ Ошибка выделения памяти \n“;
return 1;
}
*p=1000;
cout << “Целое, на которое указывает р: “ << *p << “\n”;
delete p; // освобождение памяти
return 0;
}
Динамически размещаемому объекту может быть дано начальное значение при помощи следующей формы оператора new:
p_var = new type (начальное_значение);
Например:
#include<iostream.h>
main()
{
int *p;
p=new int (9);
if (!p) {
cout << “ Ошибка выделения памяти”;
return 1;
}
cout << “Целое, на которое указывает р” << *p <<”\n”;
delete p;
return 0;
}
Можно создавать динамически размещаемые массивы объектов. Например, для одномерного массива:
p_var = new type [size];
После выполнения этого оператора p_var будет указывать на начало массива размером size элементов типа type. Однако, если память под массив выделена динамически, такой массив невозможно инициализировать.
Для удаления динамически размещенного одномерного массива используется такая форма оператора delete:
delete [] p_var;
Например:
#include<iostream.h>
main()
{
int *p;
p=new int [5];
if (!p) {
cout << “ Ошибка выделения памяти”;
return 1;
}
int i;
for (i=0; i<5; i++) p[i]=i;
for (i=0; i<5; i++){
cout << “Целое, на которое указывает р[” <<i<<”] :”;
cout << p[i] <<”\n”;
}
delete [] p;
return 0;
}