Описания классов
Класс специфицирует тип. Его имя становится typedef-имя (см. здесь), которое может быть использовано даже внутри самого спецификатора класса. Объекты класса состоят из последовательности членов.
спецификатор_класса:
заголовок_класса { список_членов opt }
заголовок_класса { список_членов opt public :
список_членов opt }
заголовок_класса:
агрег идентификатор opt
агрег идентификатор opt : public opt typedef-имя
агрег:
class
struct
union
Структура является классом, все члены которого общие; см. этот пункт. Объединение является классом, содержащим в каждый момент только один член; см. этот пункт. Список членов может описывать члены вида: данные, функция, класс, определение типа, перечисление и поле. Поля обсуждаются в здесь. Список членов может также содержать описания, регулирующие видимость имен членов; см. тут.
список_членов:
описание_члена список_членов opt
описание_члена:
спецификаторы_описания opt описатель_члена;
описатель_члена:
описатель идентификатор opt :
константное_выражение
Члены, являющиеся классовыми объектами, должны быть объектами предварительно полностью описанных классов. В частности, класс cl не может содержать объект класса cl, но он может содержать указатель на объект класса cl.
Имена объектов в различных классах не конфликтуют между собой и с обычными переменными.
Вот простой пример описания структуры:
struct tnode
{
char tword[20];
int count;
tnode *left;
tnode *right;
};
содержащей массив из 20 символов, целое и два указателя на такие же структуры. Если было дано такое описание, то описание
tnode s, *sp
описывает s как структуру данного сорта и sp как указатель на структуру данного сорта. При наличии этих описаний выражение
sp->count
ссылается на поле count структуры, на которую указывает sp;
s.left
ссылается на указатель левого поддерева структуры s; а
s.right->tword[0]
ссылается на первый символ члена tword правого поддерева структуры s.
Статические члены
Член-данные класса может быть static; члены-функции не могут. Члены не могут быть auto, register или extern. Есть единственная копия статического члена, совместно используемая всеми членами класса в программе. На статический член mem класса cl можно ссылаться cl:mem, то есть без ссылки на объект. Он существует, даже если не было создано ни одного объекта класса cl.
Функции члены
Функция, описанная как член, (без спецификатора friend (см. этот пункт)) называется функцией членом и вызывается с помощью синтаксиса члена класса (в этом пункте). Например:
struct tnode
{
char tword[20];
int count;
tnode *left;
tnode *right;
void set (char* w,tnode* l,tnode* r);
};
tnode n1, n2;
n1.set ("asdf",&n2,0);
n2.set ("ghjk",0,0);
Определение функции члена рассматривается как находящееся в области видимости ее класса. Это значит, что она может непосредственно использовать имена ее класса. Если определение функции члена находится вне описания класса, то имя функции члена должно быть уточнено именем класса с помощью записи
typedef-имя . простое_оп_имя
см. 3.3. Определения функций обсуждаются здесь Например:
void tnode.set (char* w,tnode* l,tnode* r)
{
count = strlen (w);
if (sizeof (tword) <= count) error ("tnode string too long");
strcpy (tword,w);
left = l;
right = r;
}
Имя функции tnode.set определяет то, что множество функций является членом класса tnode. Это позволяет использовать имена членов word, count, left и right. В функции члене имя члена ссылается на объект, для которого была вызвана функция. Так, в вызове n1.set(...) tword ссылается на n1.tword, а в вызове n2.set(...) он ссылается на n2.tword. В этом примере предполагается, что функции strlen, error и strcpy описаны где-то в другом месте как внешние функции (см. тут).
В члене функции ключевое слово this указывает на объект, для которого вызвана функция. Типом this в функции, которая является членом класса cl, является cl*. Если mem - член класса cl,то mem и this->mem - синонимы в функции члене класса cl (если mem не был использован в качестве имени локальной переменной в промежуточной области видимости).
Функция член может быть определена (см. тут) в описании класса. Помещение определения функции члена в описание класса является кратким видом записи описания ее в описании класса и затем определения ее как inline (см. тут) сразу после описания класса. Например:
int b;
struct x
{
int f () { return b; }
int f () { return b; }
int b;
};
означает
int b;
struct x
{
int f ();
int b;
};
inline x.f () { return b; }
Для функций членов не нужно использование спецификатора overload (этот пункт): если имя описывается как означающее несколько имен в классе, то оно перегружено (см. здесь).
Применение операции получения адреса к функциям членам допустимо. Тип параметра результирующей функции указатель на есть (...), то есть, неизвестен (этот пункт). Любое использование его является зависимым от реализации, поскольку способ инициализации указателя для вызова функции члена не определен.
Производные классы
В конструкции
агрег идентификатор:public opt typedef-имя
typedef-имя должно означать ранее описанный класс, называемый базовым классом для класса, подлежащего описанию. Говорится, что последний выводится из предшествующего. На члены базового класса можно ссылаться, как если бы они были членами производного класса, за исключением тех случаев, когда имя базового члена было переопределено в производном классе; в этом случае для ссылки на скрытое имя может использоваться такая запись (этот пункт):
typedef-имя :: идентификатор
Например:
struct base
{
int a;
int b;
};
struct derived : public base
{
int b;
int c;
};
derived d;
d.a = 1;
d.base::b = 2;
d.b = 3;
d.c = 4;
осуществляет присваивание четырем членам d.
Производный тип сам может использоваться как базовый.
Виртуальные функции
Если базовый класс base содержит (виртуальную) virtual (этот пункт) функцию vf, а производный класс derived также содержит функцию vf, то вызов vf для объекта класса derived вызывает derived::vf. Например:
struct base
{
virtual void vf ();
void f ();
};
struct derived : public base
{
void vf ();
void f ();
};
derived d;
base* bp = &d;
bp->vf ();
bp->f ();
Вызовы вызывают, соответственно, derived::vf и base::f для объекта класса derived, именованного d. Так что интерпретация вызова виртуальной функции зависит от типа объекта, для которого она вызвана, в то время как интерпретация вызова невиртуальной функции зависит только от типа указателя, обозначающего объект.
Из этого следует, что тип объектов классов с виртуальными функциями и объектов классов, выведенных из таких классов, могут быть определены во время выполнения.
Если производный класс имеет член с тем же именем, что и у виртуальной функции в базовом классе, то оба члена должны иметь одинаковый тип. Виртуальная функция не может быть другом (friend) (этот раздел). Функция f в классе, выведенном из класса, который имеет виртуальную функцию f, сама рассматривается как виртуальная. Виртуальная функция в базовом классе должна быть определена. Виртуальная функция, которая была определена в базовом классе, не нуждается в определении в производном классе. В этом случае функция, определенная для базового класса, используется во всех вызовах.
Конструкторы
Член функция с именем, совпадающим с именем ее класса, называется конструктором. Конструктор не имеет типа возвращаемого значения; он используется для конструирования значений с типом его класса. С помощью конструктора можно создавать новые объекты его типа, используя синтаксис
typedef-имя ( список_параметров opt )
Например,
complex zz = complex (1,2.3);
cprint (complex (7.8,1.2));
Объекты, созданные таким образом, не имеют имени (если конструктор не использован как инициализатор, как это было с zz выше), и их время жизни ограничено областью видимости, в которой они созданы. Они не могут рассматриваться как константы их типа. Если класс имеет конструктор, то он вызывается для каждого объекта этого класса перед тем, как этот объект будет как-либо использован; см. здесь.
Конструктор может быть overload, но не virtual или friend.
Если класс имеет базовый класс с конструктором, то конструктор для базового класса вызывается до вызова конструктора для производного класса. Конструкторы для объектов членов, если таковые есть, выполняются после конструктора базового класса и до конструктора объекта, содержащего их. Объяснение того, как могут быть специфицированы параметры для базового класса, см. в этом пункте, а того, как конструкторы могут использоваться для управления свободной памятью, см. в этой главе.
Преобразования
Конструктор, получающий один параметр, определяет преобразование из типа своего параметра в тип своего класса. Такие преобразования неявно применяются дополнительно к обычным арифметическим преобразованиям. Поэтому присваивание объекту из класса X допустимо, если или присваиваемое значение является X, или если X имеет конструктор, который получает присваиваемое значение как свой единственный параметр. Аналогично конструкторы используются для преобразования параметров функции (этот пункт) и инициализаторов (здесь). Например:
class X { ... X (int); };
f (X arg)
{
X a = 1; /* a = X (1) */
a = 2; /* a = X (2) */
f (3); /* f (X (3)) */
}
Если для класса X не найден ниодин конструктор, принимающий присваиваемый тип, то не делается никаких попыток отыскать конструктор для преобразования присваиваемого типа в тип, который мог бы быть приемлем для конструкторов класса X. Например:
class X { ... X (int); };
class X { ... Y (X); };
Y a = 1; /* недопустимо: Y (X (1)) не пробуется */
Деструкторы
Функция член класса cl с именем ~cl называется деструктором. Деструктор не возвращает никакого значения и не получает никаких параметров; он используется для уничтожения значений типа cl непосредственно перед уничтожением содержащего их объекта. Деструктор не может быть overload, virtual или friend.
Деструктор для базового класса выполняется после деструктора производного от него класса. Как деструкторы используются для управления свободной памятью, см. объяснение в этой главе.
Видимость имен членов
Члены класса, описанные с ключевым словом class, являются закрытыми, это значит, что их имена могут использоваться только функциями членами (см. здесь) и друзьями (см. этом пункте), пока они не появятся после метки public: . В этом случае они являются общими. Общий член может использоваться любой функцией. Структура является классом, все члены которого общие; см. этом пункте.
Если перед именем базового класса в описании производного класса стоит ключевое слово public, то общие члены базового класса являются общими для производного класса; если нет, то они являются закрытыми. Общий член mem закрытого базового класса base может быть описан как общий для производного класса с помощью описания вида
typedef-имя . идентификатор;
в котором typedef-имя означает базовый класс, а идентификатор есть имя члена базового класса. Такое описание может появляться в общей части производного класса.
Рассмотрим
class base
{
int a;
public:
int b,c;
int bf ();
};
class derived : base
{
int d;
public:
base.c;
int e;
int df ();
};
int ef (derived&);
Внешняя функция ef может использовать только имена c, e и df. Являясь членом derived, функция df может использовать имена b, c, bf, d, e и df, но не a. Являясь членом base, функция bf может использовать члены a, b, c и bf.
Друзья (friends)
Другом класса является функция не-член, которая может использовать имена закрытых членов. Следующий пример иллюстрирует различия между членами и друзьями:
class private
{
int a;
friend void friend_set (private*,int);
public:
void member_set (int);
};
void friend_set (private* p,int i) { p->a=i; }
void private.member_set (int i) { a = i; }
private obj;
friend_set (&obj,10);
obj.member_set (10);
Если описание friend относится к перегруженному имени или операции, то другом становится только функция с описанными типами параметров. Все функции класса cl1 могут быть сделаны друзьями класса cl2 с помощью одного описания
class cl2
{
friend cl1;
. . .
};
Функция операция
Большинство операций могут быть перегружены с тем, чтобы они могли получать в качестве операндов объекты класса.
имя_функции_операции: operator op
op: + - * / % ^ & | ~
! = < > += -= *= /= %=
^= &= |= << >> <<= >>= == !=
<= >= && || ++ -- () []
Последние две операции - это вызов функции и индексирование. Функция операция может или быть функцией членом, или получать по меньшей мере один параметр класса. См. также этот пункт.
Структуры
Структура есть класс, все члены которого общие. Это значит, что
struct s { ... };
эквивалентно
class s { public: ... };
Структура может иметь функции члены (включая конструкторы и деструкторы).
Объединения
Объединение можно считать структурой, все объекты члены которой начинаются со смещения 0, и размер которой достаточен для содержания любого из ее объектов членов. В каждый момент времени в объединении может храниться не больше одного из объектов членов. Объединение может иметь функции члены (включая конструкторы и деструкторы).
Поля бит
Описатель члена вида
идентификатор opt: константное_выражение
определяет поле; его длина отделяется от имени поля двоеточием. Поля упаковываются в машинные целые; они не являются альтернативой слов. Поле , не влезающее в оставшееся в целом место, помещается в следующее слово. Поле не может быть шире слова. На некоторых машинах они размещаются справа налево, а на некоторых слева направо; см. #2.6.
Неименованные поля полезны при заполнении для согласования внешне предписанных размещений (форматов). В особых случаях неименованные поля длины 0 задают выравнивание следующего поля по границе слова. Не требуется аппаратной поддержки любых полей, кроме целых. Более того, даже целые поля могут рассматриваться как unsigned. По этим причинам рекомендуется описывать поля как unsigned. К полям не может применяться операция получения адреса &, поэтому нет указателей на поля.
Поля не могут быть членами объединения.
Вложенные классы
Класс может быть описан внутри другого класса. В этом случае область видимости имен внутреннего класса его и общих имен ограничивается охватывающим классом. За исключением этого ограничения допустимо, чтобы внутренний класс уже был описан вне охватывающего класса. Описание одного класса внутри другого не влияет на правила доступа к закрытым членам и не помещает функции члены внутреннего класса в область видимости охватывающего класса. Например:
int x;
class enclose /* охватывающий */
{
int x;
class inner
{
int y;
f () { x=1 }
...
};
g (inner*);
...
};
int inner; /* вложенный */
enclose.g (inner* p) { ... }
В этом примере x в f ссылается на x, описанный перед классом enclose. Поскольку y является закрытым членом inner, g не может его использовать. Поскольку g является членом enclose, имена, использованные в g, считаются находящимися в области видимости класса enclose. Поэтому inner в описании параметров g относится к охваченному типу inner, а не к int.
1 2 3 4 5 6
8 8 8
| 
*
Обратная связь