Void stringxy(char *str, int X, int y)

{

if(x= = -1) x=wherex();

if(y= = -1) y=wherey();

gotoxy(x,y);

cout<<str;

}

Следует отметить, что при вызове функции stringxy() из главной программы указано разное количество аргументов. С++ это допускает. Но значения, которые берутся по умолчанию, должны находиться после аргументов, значения которых не заданы по умолчанию.

Структуры и классы

Структуры в С++ обладают теми же возможностями, что и классы. В С++ структуры и классы, за одним исключением могут быть взаимозаменяемыми. Структура может включать данные и правила обработки этих данных. Различие структур и классов в С++ состоит в том, что члены класса по умолчанию имеют режим доступа private, а в структуре члены структуры по умолчанию public.

Пример объявления структуры queue.

struct queue {

private:

int q[100];

int sloc,rloc;

int id; // идентификатор объекта

public:

queue(void); // конструктор по умолчанию

queue(int i); // конструктор инициализации

~queue(void); // деструктор

void qput(int); // прототипы

int qget(void); // функций

};

Объявление объектов структуры queue obj(1), obj2;

Объединения и классы

Union и class имеют много общего. Union может иметь конструктор, деструктор и дружественные функции. Все члены union по умолчанию public. Ключевые слова private, protected, public не могут использоваться в union. Union не могут использоваться в наследовании ни как базовый, ни как производный типы.

В С++ можно использовать неименованные (anonimus) union:

union {список-элементов};

Неименованные union определяют объект, а не тип. Имена элементов union используются без операции точка, и имена должны отличаться от других имен из области действия.

Пример:

#include <iostream.h>

Void main()

{

union { long l; unsigned char ch[4];};

cout<<”\n Give number type long:”;

cin>>l;

cout<<” 1 byte:”<<int(ch[0])<<endl;

cout<<” 2 byte:”<<int(ch[1])<<endl;

cout<<” 3 byte:”<<int(ch[2])<<endl;

cout<<” 4 byte:”<<int(ch[3])<<endl;

}

Число long разбирается по байтам и выводятся целые значения этих байтов.

Наследование классов

Терминология:

Класс, который наследуется – базовый класс (base class);

Класс, который является наследником – производный класс (derived class) (или child class);

Режимы доступа: public, private, protected.

Общие элементы могут быть доступны другим функциям программы. Приватные и защищенные элементы могут быть доступны только функциям-членам или дружественным функциям. Когда один класс наследует другой, все приватные элементы базового класса недоступны для производного класса.

Пример

class X { // Базовый класс

int i,j;

public:

void get_ij(void);

void put_ij(void);

};

class Y: public X { // Производный класс

int k;

public:

int get_k(void);

void make_k(void);

};

Функции-члены класса Y могут использовать общие функции get_ij() и put_ij(), но они не могут использовать i и j, так как они приватные для X и, соответственно, недоступны для функций get_k(), make_k() класса Y.

Для обеспечения доступа членов-функций класса Y к элементам i и j класса X нужно в классе X объявить их protected

class X { // Базовый класс

protected:

int i,j;

public:

…

Отметим, что в то же время i и j остаются недоступными для остальной части программы.

Основная форма наследования

class имя-производного-класса: режим-доступа имя-базового-класса {…};

режим доступа {private, protected, public}

Если режим доступа отсутствует, то по умолчанию:

public – если производный класс структура;

private – если производный класс class.

Схема режимов доступа при наследовании

Режим доступа к элементу в базовом классе	Режим доступа при наследовании	Режим доступа к элементу в производном классе
private		недоступен
protected	---- public	protected
public		public
private		недоступен
protected	---- protected	protected
public		protected
private		недоступен
protected	---- private	private
public		private

// Наследование режима доступа

#include <iostream.h>

class X{

protected:

int i,j;

public:

int get_ij(void);

void put_ij(void);

};

class Y:public X{

int k;

public:

int get_k(void);

void make_k(void);

}; // i,j стали protected членами в классе Y

class Z:public Y{

public:

void f(void);

};

// Z имеет доступ к переменным класса Х

// Z не имеет доступа к переменной k класса Y

void X::get_ij(void)

{

cout<<”Введите два числа:”;

cin>>i>>j;

}

void X::put_ij(void)

{

cout<<”i=”<<i<<” j=”<<j<<endl;

}

int Y::get_k(void)

{

return k;

}

void Y::make_k(void)

{

k=i*j;

}

void Z::f(void)

{

i=2; j=3;

}

void main(void)

{

Y v1;

Z v2;

v1.get_ij();

v1.put_ij();

v1.make_k();

cout<<v1.get_k()<<endl;

v2.f();

v2.put_ij();

v2.make_k();

cout<<v1.get_k();

cout<<end;

}

// простое наследование

#include <stdio.h>

#include <conio.h>

#include <iostream.h>

#include <string.h>

const int MAX_LEN =10;

class Coord

{

protected:

int x,y;

public:

Coord(int _x=0, int _y=0);

void SetLoc(int _x, int _y);

};

Coord::Coord(int _x, int _y)

{

SetLoc(_x,_y);

}

void Coord::SetLoc(int _x, int _y)

{

x = _x;

y = _y;

}

//MsgAtCoord: Содержит сообщение, наследует от Coord

class MsgAtCoord : public Coord

{

char msg[MAX_LEN];

public:

MsgAtCoord(char *_msg = “NO MSG” );

void SetMsg(char *_msg);

void Show();

};

MsgAtCoord::MsgAtCoord( char *_msg)

{

SetMsg( _msg);

}

void MsgAtCoord::SetMsg(char *_msg)

{

strcpu( msg, _msg);

}

void MsgAtCoord::Show()

{

gotoxy(x,y);

printf( msg);

}

void main(void)

{

MsgAtCoord greeting;

greeting.SetLoc( 10, 10);

greeting.SetMsg(“ hello…”);

greeting.Show();

}