C++ осень 2012 лекция 11

•
•
•
// пустой бесконечный цикл
for(;;);
// цикл с тождественно истинным условием
while(1) foo();
// постфиксный декремент, адресная арифметика и др.
while(*cp1++ = *cp2++);

•
•
•
•
•
•
•
•
•
operator = operator << operator >>

public private
std::pair<T1, T2>
boost::is_void<T>
std::vector<T>

•
•
•
•
•
class A;
A a; // вызов A::A(), если есть
// ...
A b(a); // вызов A::A(A&), если есть

this
class A;
A *pa = new A(42); // вызов A::A(int)
A *pa2 = new A[N]; // вызов A::A(), N раз
// ...
// освобождение памяти с вызовом A::~A()
delete [] pa2;
// освобождение памяти без вызова A::~A()
// delete pa2;

• operator []
• operator new
• operator delete
• operator ->
• operator double operator
char

class ARef // фиктивный класс
{
public:
ARef(A &a, int i) : _a(a), _ix(i) { }
ARef& operator= (T t) { /* запись t в _a */
return *this;
}
operator T() { /* чтение из _a в _t */
return _t;
}
private:
A& _a; // ссылка на агрегат
int _ix; // индекс в агрегате
T _t; // T – гл. обр. базовый тип
};

class A // агрегат
{
friend class ARef; // для повышения производит.
public:
A() { /* ... */ }
ARef operator[] (int ix) {
return ARef(*this, ix);
}
};
// в точке использования
A a; int i, j; T t;
// ...
a[i] = t; // (a.operator[](i)).operator=(t);
t = a[j]; // t = (a.operator[](j)).operator T();

class StringRep // класс-представление
{
friend class String;
private:
StringRep(const char *s) : _count(1) {
strcpy(_rep = new char[strlen(s) + 1],
s);
}
~StringRep() { delete [] _rep; }
private:
char* _rep; // общее представление
int _count; // количество ссылок
};

class String // класс-строка
{
public:
String() { rep = new StringRep(“”); }
String(const String& s)
{ rep = s.rep; rep->_count++; }
String& operator=(const String& s) {
s.rep->_count++;
if(--rep->_count <= 0) delete rep;
rep = s.rep; return *this;
}
~String() {
if(--rep->_count <= 0) delete rep;
}

// class String
String(const char *s)
{ rep = new StringRep(s); }
int length() const // делегирование
{ return strlen(rep->_rep); }
private:
StringRep *rep; // общее представление
};

class StringRep // класс-представление
{
friend class String;
private:
StringRep() { *(_rep = new char[1]) = „0‟; }
StringRep(const StringRep& s) {
strcpy(_rep = new char[
strlen(s._rep) + 1],
s._rep);
}
StringRep(const char *s) {
strcpy(_rep = new char[strlen(s) + 1],
s);
}

// class StringRep
~StringRep() { delete [] _rep; }
int length() const { return strlen(_rep); }
private:
char* _rep; // общее представление
int _count; // количество указателей
};
class String // класс-строка
{
public:
String() {(p = new StringRep())->_count = 1;}
String(const String& s) {
(p = s.p)->_count++;
}

// class String
String(const char *s) {
(p = new StringRep(s))->_count = 1;
}
StringRep* operator->() const { return p; }
String& operator=(const String& q) {
if(--p->_count <= 0 && p != q.p)
delete p;
(p = q.p)->_count++;
return *this;
}
~String() { if(--p->_count <= 0) delete p; }
private:
StringRep *p; // общее представление
};

void* operator new(std::size_t size);
void operator delete(void* ptr);
// для «размещающего» new: T *pt = new (buf) T(val);
void* operator new(std::size_t, void* p);

operator new operator
delete
•
•
•

class String
{
public:
String() { /* _rep = ... */ }
String(const char *s) { /* _rep = ... */ }
~String() { delete[] _rep; }
void* operator new(std::size_t);
void operator delete(void*);
private:
static String *_list; // список своб. блоков
// указатель на следующий блок
// или представление строки
union { String *_freeptr; char *_rep; };
};

String *String::_list = NULL;
void String::operator delete(void *p)
{
String *s = (String *)p;
s->_freeptr = _list;
_list = s;
}

void* String::operator new(std::size_t /* size */)
{
if(!_list) {
int i = 0;
for(_list = (String*)new char
[POOL_SIZE * sizeof(String)];
i < POOL_SIZE - 1; i++)
_list[i]->_freeptr =
&(_list[i + 1]);
_list[i]->_freeptr = NULL;
}
String *aList = _list;_list = _list->_freeptr;
return aList;
}

struct BaseConstructor{BaseConstructor(int = 0){}};
class Base // класс-конверт
{
public:
Base() { _rep = new DerivedOne; }
Base(T t) { _rep = new DerivedOne(t); }
Base(T t,U u) { _rep = new DerivedTwo(t,u); }
Base(Base &b) { /* ... */ }
Base& operator=(Base &b) { /* ... */ }
virtual Base& operator+(const Base &b) {
return _rep->operator+(b);
}

// class Base
void Redefine(Base *pb)
{
if(!(--_rep->_refCount)) delete _rep;
_rep = pb;
}
protected:
Base(BaseConstructor) : _refCount(1) { }
private:
Base* _rep; // адрес экз. письма
int _refCount; // количество ссылок
};

class DerivedOne : public Base
{
public:
DerivedOne(T t) :
Base(BaseConstructor()), _refCount(1)
{ /* ... */ }
Base& operator+(const Base &b) { /* ... */ }
// ...
private:
// ...
};

class Base;
inline void *operator new(std::size_t, Base *b)
{ return b; }
unsigned char buf[BUF_SIZE], *pbuf = &buf;
class Base // класс, «создаваемый» пользователем
{
public:
void *operator new(std::size_t)
{ return (void*) pbuf; }
Base() { /* ПУСТО */ }
Base(T t) { /* ... */
(void) new(this) Derived(t); /* ... */
}
};

// выравнивание адреса a на границу в b байт
inline int round(int a, int b)
{ return ((a + b – 1) / b) * b; }
class Derived : public Base
{
private:
Derived(T t) : Base()
{
// ...
// выравнивание на границу DWORD
pbuf += round(sizeof(Derived), 0x04);
}
};

•
•
•
•
•
•
•
•

•
•
•
•
• gets()
•
•
•

•
•
•
•
•
•
•
•
•

C++ осень 2012 лекция 11

More Related Content

What's hot (19)

Viewers also liked (19)

Similar to C++ осень 2012 лекция 11 (20)

More from Technopark (20)

C++ осень 2012 лекция 11