struct Node Node next void data struct List

Данные отдельно, методы отдельно struct Node { Node* next; void* data; }; struct List { Node* first; int size; }; void* allocate() { … } void add (void* cont, void* data) { … } int size (void* cont) { … } void* remove (void* cont, int pos) { … } void release(void* cont) { … } void main() { int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; List* list = (List*)allocate(); add(list, a+1); add(list, a+5); remove(list, 1); printf(“Size: %d”, size(list)); release(list); }

Проблема № 1: подаем некорректные данные void main() { int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; void* bbb = NULL; List* list = (List*)allocate(); add(bbb, a+1); add(a, a+5); remove(a, 1); printf(“Size: %d”, size(bbb)); release(list); }

Данные и методы вместе (объект) struct Node { Node* next; void* data; }; void* allocate() { … } void release(void* cont) { … } struct List { Node* first; int size; void add (void* data) { … } int size () { … } void* remove (int pos) { … } } void main() { int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; List* list = (List*)allocate(); list->add(a+1); list->add(a+5); list->remove(1); printf(“Size: %d”, list->size()); release(list); }

Проблема № 2: не защищено создание и удаление void main() { int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; void* bbb = NULL; List* list = (int*)allocate(); list->add(a+1); list->add(a+5); list->remove(1); printf(“Size: %d”, list->size()); release(bbb); } void main() { int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; void* bbb = NULL; List list = ? ? ? // мы знаем только как создавать указатель на структуру List }

Не получается struct List { Node* first; int size; void main() { int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; void* bbb = NULL; List* list = ? ? ? ->allocate(); list->add(a+1); list->add(a+5); list->remove(1); printf(“Size: %d”, list->size()); void add (void* data) { … } List* allocate() { … } List allocate 2() { … } void release() { … } } list->release(); free(list); // две операции }

Конструктор и деструктор struct Node { Node* next; void* data; }; void main() { int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; List* list = new List(); list->add(a+1); list->add(a+5); list->remove(1); printf(“Size: %d”, list->size()); delete list; // ~List() struct List { Node* first; int size; } List() { … } // конструктор } void add (void* data) { … } int size () { … } void* remove (int pos) { … } ~List() { …} // деструктор void main() { int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; List list(); list. add(a+1); list. add(a+5); list. remove(1); printf(“Size: %d”, list. size()); } // после завершения функции выполнится деструктор ~List()

Защищаем доступ. Инкапсуляция. struct Node { Node* next; void* data; }; void main() { int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; List* list = new List(); list->add(a+1); list->add(a+5); list->remove(1); list->first = NULL; // ошибка компиляции list->size = 1000; // ошибка компиляции printf(“Size: %d”, list->size()); list->touch(); // ошибка компиляции delete list; // ~List() class List { private: Node* first; int size; public: List() { … } // конструктор void add (void* data) { touch(); // no problem … } int size () { return size; // no problem } void* remove (int pos) { touch(); … } ~List() { …} // деструктор private: void touch() { // запоминаем время } } }

Соглашение: разделение интерфейса и реализации Файл List. hpp class List; class Node { friend List; private: Node* next; void* data; Node(); }; class List { private: Node* first; int size; public: List(); // конструктор Файл List. cpp #include “List. hpp” Node: : Node() { … } List: : List() { // конструктор … } void List: : add (void* data) { … } void add (void* data); void* List: : remove (int pos) { … } int size () { return size; // можно оставить } List: : ~List() { … } void* remove (int pos) ; List: : touch(){ … } ~List(); // деструктор private: void touch() ; }

Бонус: переопределение операций class Complex { private: float my. Real; float my. Imag; public: Complex(float re, float im) { my. Real = re; my. Imag = im; } Complex operator+(Complex c) { Complex sum(my. Real+c. my. Real, my. Imag+c. my. Imag); return sum; } Complex operator+(double re) { Complex sum(my. Real+re, my. Imag); return sum; } Complex operator+(int re) { Complex sum(my. Real+re, my. Imag); return sum; } void print() { printf("Complex: %f %fn", my. Real, my. Imag); } float& operator[] (int pos) { if (pos ==0) return my. Real; else return my. Imag; } }; // end of class definition // внещний оператор Complex operator+(double d, Complex c 2) { Complex sum(d+c 2. Real(), c 2. Imag()); return sum; }

Бонус: переопределение операций void main() { Complex c 1 (1. 1, 0); Complex c 2 (9, 9. 9); int i = 0; double d = 0. 0; Complex c = c 1 + c 2; // Вызов: Complex operator+(Complex c) {…} c = c 1 + i; // Вызов: Complex operator+(int re) {…} c = c 1 + d; // Вызов: Complex operator+(double re) {…} c = d + с1; // Вызов: Complex operator+(double d, Complex c 2) {…} c[0] = 1; // Вызов: float& operator[] (int pos) {…} c[1] = 8; // Вызов: float& operator[] (int pos) {…} c. print(); }