Статические поля класса С++

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

class student

{ …

static int count;

public:

student (char *f, char *n, int a = 20) : age (a)

{ fam = new char [20]; name = new char [20];

strcpy (fam, f); strcpy (name, n); count++; }

…

void showcount() { cout

static void setcount (int n) { count = n; }

};

int student :: count;

int main ()

{ student::setcount(0);

student a("Ivanov", "Boris"), b("Sokolova", "Olga", 19);

a.showcount();

return 0;

}

Константные методы определены со словом const и не могут изменять поля объекта.

Константные объекты недоступны для изменения. Для таких объектов можно использовать только константные методы.

class student

{ …

void show () const

{ cout

…

};

int main ()

{ const student a("Ivanov", "Boris"), b("Sokolova", "Olga", 19);

a.show(); b.show();

return 0;

}

Дружественные функции могут получить доступ к скрытым элементам класса.

Дружественная функция объявляется внутри класса с ключевым словом friend.

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

Одна функция может быть дружественной для нескольких классов.

Класс может быть описан как дружественный внутри другого класса. Все методы дружественного класса могут получить доступ к скрытым элементам класса.

class _time

{ int h,m;

public:

_time ( int hours = 0, int minutes = 0)

{ h = hours; m = minutes; }

friend void settime( _time &t, int hr, int mn)

{ t.h = hr; t.m = mn; }

void show()

{ cout

… .

};

int main()

{ _time t ; settime(t,11,10); t.show(); return 0; }

С++ позволяет переопределить операции так, чтобы они работали с экземплярами классов.

Перегрузить можно все операции кроме

. ?: :: sizeof

При перегрузке сохраняются количество аргументов, приоритеты операций и правила ассоциаций.

Перегрузка производится с помощью специальных функций-операций : operator

Функции-операции не наследуются и не могут быть статическими.Функция-операция может быть дружественной функцией либо методом класса.

60) { h++; m-=60; } h = h % 24; return _ t ime(h,m) ; } _ time & operator ++ () { ++m; if (m == 60) { ++h; m=0; } h = h % 24; return *this; } _time operator ++ (int) { _time t = *this; ++m; if (m == 60) { ++h; m=0; } h = h % 24; return t; } }; int main() { _time t(12,30), p (14, 35) , r; r = t + p; p = ++ r; t = r++; r.show(); p.show(); t.show(); return 0;} " width="640"

class _time

{ …

friend _time operator+ (_time time1, _time time2)

{ int h = time1.h + time2.h; int m = time1.m + time2.m;

if (m60) { h++; m-=60; } h = h % 24; return _ t ime(h,m) ; }

_ time & operator ++ () {

++m; if (m == 60) { ++h; m=0; } h = h % 24;

return *this; }

_time operator ++ (int) {

_time t = *this; ++m; if (m == 60) { ++h; m=0; }

h = h % 24; return t; }

};

int main() { _time t(12,30), p (14, 35) , r;

r = t + p; p = ++ r; t = r++; r.show(); p.show();

t.show(); return 0;}

T& operator = (const T&)

Пример:

_time & operator =(const _time & t)

{ h = t.h; m = t.m; return *this; }

class vector

{ int size; int *p;

public:

vector ( int n = 10) : size(n) { p = new int [size]; }

~vector () { delete [] p; }

int& operator [] (int i)

{ if (isize)

{ cout

r eturn p[i];}

};

int main()

{ vector a (3) ;

a[0] = 1; a[1] = 2; a[2] = 3;

a.show(); return 0;}

Операция не имеет возвращаемого значения и параметров.

operator имя_типа()

class _time { …

operator int() {return h*60+m;}

…

}

int main()

{ _time t (15,20);

cout

}

Обратное преобразование выполняет конструктор с единственным параметром.

b ? a : b; } }; int main() {cout } " width="640"

В функциональном классе переопределена операция вызова функции () .

class maximum

{ public:

int operator () (int a, int b)

{ return ab ? a : b; }

};

int main()

{cout

}