Управление памятью

известен, можно создавать в куче (или стеке)
Операция new создает объект

в куче
выделяет память
вызывает конструктор
возвращает указатель на объект (или NULL, если нет свободной памяти)
Объект существует до его явного уничтожения операцией delete
Операция delete уничтожает объект
вызывает деструктор
освобождает память

ptr;
ptr = new int;
*ptr = 75;
return ptr;
}

void func2( ) {
int*

ptr2;
ptr2 = func();
delete ptr2;
}

] ) {
// Динамическое размещение
// объекта типа String
String* ptr1 ;
ptr1

= new String ;
if( ptr1 == 0 ) exit(1) ;
*ptr1 = “Hello, world”;
(*ptr1 + “\n”).print();
// Динамическое размещение и
// инициализация объекта String
String* ptr2 ;
ptr2 = new String(“Hello, world”) ;
if( ptr2 == 0 ) exit(2) ;
(*ptr2 + “\n”).print();

// Динамическое размещение
// массива объектов типа String
String* ptr3 ;
ptr3 = new String[argc] ;
if( ptr3 == 0 ) exit(1) ;
ptr3[argc-1] = “Hello, world”;
(ptr3[argc-1] + “\n”).print();
// Уничтожение объектов
delete ptr1 ;
delete ptr2 ;
delete [argc] ptr3 ;
// или delete [] ptr3 ;
}

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

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

const String& ) ;
~String() ;
operator const char*( ) const;
String& operator=

( const String& );
int length( ) const ;
int read( ); // чтение из stdin
void print( ) const; // вывод в stdout
char& operator[ ] ( int );
const char& operator[ ] ( int ) const;
String substring (int start, int len) const;
friend String operator+ (const String&, const String& );
private:
// text указывает на область динамической памяти,
// всегда завершающуюся терминальным байтом
char* text ;
};

адрес

стек
куча

адрес
Hello\0

= new String ;
перед конструктором
выделена память под указатель text

после

конструктора

text

адрес

text

‘\0’

String::String() {
if( !(text = new char) )
error_msg(“Нет памяти для пустой строки”) ;
*text = ‘\0’ ;
}

Синтаксис

;
s_ptr = new String(“Hello”) ;
выделена память под указатель text
перед конструктором

после конструктора

text

адрес

text

“Hello\0”

String::String( const char* s ) {
if( !(text = new char[strlen(s)+1]) )
error_msg(“Нет памяти для строки \n” ) ;
strcpy( text , s) ;
}

Синтаксис

s_ptr ;
s_ptr = new String(t) ;
выделена память под указатель text
перед

конструктором

после конструктора

text

адрес

text

“Hello\0”

String::String( const String& s ) {
if( !(text = new char[s.length()+1]) )
error_msg(“Нет памяти для строки \n” ) ;
strcpy( text , s.text ) ;
}

Синтаксис

…………
delete s_ptr ;
// или s уничтожается
// автоматически
перед деструктором
память занята под

указатель text

после деструктора

text

адрес

text

“Hello\0”

String::~String( ) { delete text ; }

Синтаксис

адрес
text
‘\0’
Синтаксис:
t
адрес
text
“Hello\0”
s
после присваивания
адрес
text
t
адрес
text
“Hello\0”
s
“Hello\0”

if( this != &s ) { // на случай t=t

delete text ; // освободить старую память
if( !(text = new char[s.length()+1]) )
error_msg(“Нет памяти для строки \n” ) ;
strcpy( text , s.text ) ;
}
return *this ;
}

String& s2 ) {
String both ;
delete

both.text ;
if( !(both.text = new char[s1.length()+s2.length()+1]) )
error_msg(“Нет памяти для строки \n” ) ;
strcpy( both.text , s1.text ) ;
strcat( both.text , s2.text ) ;
return both ;
}

= new char[ strlen(s)+1]) )

error_msg(“Нет памяти для строки \n” ) ;
strcpy( text , s ) ;
}

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

) { alloc_and_set(s.text); }
String::String( const char* s ) { alloc_and_set(

s ); }
String& String::operator=(const String& s) {
if( this != &s ) { // на случай t=t
delete text ; // освободить старую память
alloc_and_set( s.text );
}
return *this ;
}

) {
String both ;
delete

both.text ;
if( !(both.text = new char[s1.length()+s2.length()+1]) )
error_msg(“Нет памяти для строки \n” ) ;
strcpy( both.text , s1.text ) ;
strcat( both.text , s2.text ) ;
return both ;
}

Операция конкатенации неэффективна:
создается переменная both (вызов конструктора)
манипуляции с динамической памятью
возврат результата (вызов конструктора)

if( !(text = new char[ srtlen(s1) + srtlen(s2)

+ 1]) )
error_msg(“Нет памяти для строки \n” ) ;
strcpy( text , s1 ) ;
strcat( text , s2 ) ;
}
inline String operator+(const String& s1 , const String& s2 )
{
return String( s1.text , s2.text ) ;
}

, const char* );
void alloc_and_set(const char* );
// text указывает

на область динамической
// памяти, всегда завершающуюся
// терминальным байтом
char* text ;
};

реализация позволяет сосредоточиться на интерфейсе
Изменение реализации не требует изменений программ

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

полем len, а сама строка была динамическим массивом символов, но

без терминального байта:
class String {
public:
// те же методы класса
private:
int len;
char* text ;
}

быть объявлен в файле intarray.h. Код методов поместите в любой

файл (или файлы), по своему усмотрению 
Спецификация класса intArray
Размер массива Int_array должен задаваться при его создании:
intArray ia(10);
Доступ к элементам массива осуществляется с помощью операции []. (Заметим, что для этого не требуется метод operator=() ).
ia[0] = 100; ia[1] = 10;
Программа прерывается, если задается некорректный индекс:
  ia[9] = 17; // все нормально
ia[5000] = 508; // программа прерывается

, находящийся слева, получает размер и все элементы массива intArray

, находящегося справа:
intArray ia2(7);
ia2[0] = -1;
ia2 = ia;
Если массив intArray передается функции по значению, функция получает копию этого массива:
test(ia2);
printf("ia2[9] should still be 17: %d\n", ia2[9]);
// тестом является следующий код:
void test(intArray copy) {
printf("copy[9] should be 17: %d\n", copy[9]);
copy[9] = -1;
printf("copy[9] changed to -1: %d\n", copy[9]);
}