Вы находитесь на странице: 1из 50

( ) ,

.
class:
class ClassName //
{
/* { } */
public: //
/* public */
} mc1; // mc1 ClassName
ClassName mc2; // mc2 ClassName

struct,
class,
public.

:
class MyClass2; // MyClass2
class MyClass1 // MyClass1
{
/* */
protected:
MyClass2 mc; // mc MyClass2
};
class MyClass2// MyClass2
{ };

- , - .
( Visual C++ -,
, , ). -, (.
), . -
(. ).
-
.
-:
class MyClass
{
public:
int i_1; // -
int i_2;
int Sum_i(int d) // -
{
/* - */
int s_i;
s_i = d + i_1 + i_2;
return(s_i);
}
void _function(int); // -
};

void MyClass::_function(int d)
{ /* - */ }

-, ,
(, inline) (

,
). - inline, -,
, ,
.
inline-
. ,
.
, ,
, inline-
, .
, -
inline-.
(.h)
(.pp) .
,
.
,
, ,
. C++. -,
, inline-,
.
-
, ; ,
, ,
.
-
, .

- (public),
(private, protected) .
- .
- .


/* _ :: __ */
MyClass::_var // -
MyClass::_function(char, int) // -
::_fn(char) // -

::
, ,
.
( )
, .
.
, . ::
- , .

this
- ,
. this .
class MyClass
{
public:
MyClass& _function(void)
};

MyClass& MyClass::_function(void)
{ return *this }

void main(void)

{
MyClass mc1;
MyClass mc2;
mc2 = mc1._function();
}

- _function ,
.
, -,
"", ,
-, . ,

.
this
, . :
MyClass& MyClass::assign(const MyClass &source)
{
if (this != &source)
{
this->~MyClass();
new (this) MyClass(source); // new
}
return *this;
};

new MyClass
, , this.

- const

. ,
, .
-.
:
const MyClass mc;

,
(, )
(, ) -:
class MyClass
{
public:
int get_x() // -
{ return x; }
void set_x(int i) // -
{ x = i; }
protected:
int x;
};

, -
, const:
class MyClass
{
public:
int get_x() const // -

{ return x; }
void set_x(int i) // -
{ x = i; }
protected:
int x;
};

-,

.
-,
. ,
, ,
. , const

.
const -
.
, -
-.
class MyClass
{
public:
int get_x()
{ return x; }
void set_x(int i)
{ x = i; } //
protected:
int x;
};

const MyClass mc;


mc. get_x();
mc. set_x(13);

. C++Builder
, - get_x
set_x .
,
,
.
-
.
const ,
.

(mutable)
, -
,
mutable ():
class MyClass
{
public:
mutable int x;
};

const MyClass mc;


mc.x = 13; // !


.NET ,
(garbage collection), ""
.
, ,
.NET .
.NET , ,
.
,
__gc, :
__gc class Point List
{
public:
int nX;
int nY;
PointList *poNext;
}



, .
.
,
public, private protected
.
, public, ,
private protected
.
- (
private) .
- (. ) .

- ,
.

.

private.
protected.
-, ,
- , (. ).

,
.
friend ().
class MyClass;
{
friend int fn(void); // friend
public:
int pub_i;
private:
int pri_i;
protected:
int pro_i;
};

int fn(void) // fn MyClass


{
MyClass MC;

MC. pub_i = 0;
MC. pri_i = 0;
MC. pro_i = 0;
}

. , ,
. , ,
. ,
,
.
-
:
class MyClass1
{
public:
void fn(void);
};
class MyClass2
{
/* - MyClass1 MyClass2 */
friend void MyClass1::fn(void);
public:
/* */
protected:
int i;
};

void MyClass1::fn(void) // - MyClass1

{
MyClass2 mc;
mc.i = 0;
}
- , -
, MyClass2 .

. , -
, :
class MyClass1
{
public:
void fn(void);
};

class MyClass2
{
friend class MyClass1; // MyClass1 MyClass2
public:
/* */
protected:
int pro_i;
};

void MyClass1::fn(void) // - MyClass1


{
MyClass2 mc;

mc. pro_i = 0;
}

- MyClass1
MyClass2.
.


- ,
(static).
-. ,
.
,
,
.
-
static:

class MyClass
{
public:
MyClass() { }
~MyClass() { }
protected:
static int i;
};


. ,


, .


.
.
int MyClass::i = 0;

.
,
, ,
- .

: .

//
class MyClass
{
// ...
private:
static const int Size = 16;
};
//
const int MyClass::Size; //

,
.
, .
, ,
(!),
.
class MyClass
{
public:
static int i;
MyClass& fn(); // fn MyClass
};

void main(MyClass& mc)


{
int x;
x = mc.fn().i;
}

- fn() . :
, (, Borland C++
).

-
- .
-, , -
. ,
-, -,
. , .
- ,
: static,
const volatile . ,
, static .
- -
, .
class MyClass
{
public:
static int fn()
{
int x, y;

x = i; // !
y = s_i;
return y;
}
protected:
int i;
static int s_i;
};

, -
-. ,
.
- this ,
.
- ,
.
, ,
.
- ,
, .

,
. -
, . ,
.
, .

.

, . :
union MyUnion
{
char _cval;
int _ival;
char *_sval;
double _dval;
};

MyUnion _dval,
MyUnion double.
, ,
.
.
, .
,
. , ,
.
-,
.
, , ,
,

. , _ival,
, _sval. , ,
.
,
, ,
, .
.
,
.
class MyClass
{
public:
union {
int _ival;
double _dval;
} val;
};

,
.
class MyClass
{
public:
union {
int _ival;
double _dval;
};
};

-
, .

void main(void)
{
MyClass val;
val. _ival = 13;
}

,
MyClass.
, -.
, ,

static.

,

, .
, .
class File
{
// ...
unsigned int bf : 1; //
};

,
, . , bf
.
, ,
,
. ,
unsigned int,
bf_1:
typedef unsigned int Bit;
class MyClass {
public:
Bit bf_1 : 2;
Bit bf_2 : 1;
Bit bf_3 : 3;
Bit bf_4 : 3;
Bit bf_5 : 3;
//
};

(&),
-. ,
.
C++ bitset,
.
.


,

.
-,
.
-, ,
.
, :
MyClass::MyClass();

- void.
. (private), (public)
(protected).
,
.
!
-, ,
.
:
class MyClass
{
public:
MyClass(); // ( !)
MyClass(int); //
};

MyClass:: MyClass(int i) //

{
/* */
}

int main(int arg)


{
MyClass mc1; //
MyClass mc2(5); //
return 0;
}
MyClass();,
, MyClass mc1;. ,
MyClass(int). -
( MyClass(int))
, (
MyClass();).

()
-
. .

. , int,
double .. ,
- ,
.
:
Window::Window(int Left, int Right);
Window::Window(int Width, int Color);

.
,
. ,
int, ,
int. double,
, double.

,
.
class MyClass
{
public:
int i;
MyClass (); // 1
MyClass (int); // 2
protected:
float fl;
};

MyClass::MyClass ()
{
i = 13;
}

MyClass::MyClass (int ii)


{
i = ii +1;
}

void main(void)
{
MyClass mc1; // 1, mc.i == 13
MyClass mc2(5); // 2, mc.i == 6
}

mc1 ! ,
mc1, 1
, ,
MyClass.
, !



.
, ,
.
. ,
, ,
(
, -
, ).


, C++ ,

MyClass::MyClass(mc&) MyClass::MyClass(const mc&), mc


MyClass. MyClass,
MyClass.
!

class MyClass
{
public:
int y;
/* */
MyClass(int ii)
{
y = 5;
x = ii;
/* */
}
/* */
MyClass(MyClass& mc)
{
/* */
x = 13;
}
protected:
int x;
};
int main()
{
MyClass n1(5); // n1
/* n1.x == 5; n1.y == 5; */
MyClass n2(n1); // n2

/* n1.x == 13; n1.y == 5; */


}
,

. , - ,
x 13.


.

( ),
.
class MyClass1
{
public:
MyClass1(int i)
{
/* */
}
MyClass1(MyClass1& m)
{
/* */
}
};

class MyClass2
{
public:

MyClass2(MyClass1& mc) : mc1(mc), mc2(mc)


{
/* */
}
protected:
MyClass1 mc1; // ( mc)
MyClass1 mc2; // ( mc)
};

void main(void)
{
MyClass1 n1(7);
MyClass2 n2(n1);
}


1:
class MyClass
{
public:
MyClass()
{
/* */
p = new int; //
}

protected:
int *p; // int
};

void main(void)
{
MyClass mc1;
mc2 = mc1; //
}

mc1 MyClass
int. - mc1.p
int. mc1.p
mc2.p .
(shallow) ,
.

mc1

mc1

mc2

2:
class MyClass
{
public:
MyClass(MyClass& mc)

{
/* */
p = new int; //
}
protected:
int *p; // int
};

void main(void)
{
MyClass mc1;
MyClass mc2(mc1); //
}

(deep),
, .

mc1

mc1

mc2

: ,
.

-,
. .
, - ,
, . ,
new, delete.
, ,
.
, ,
(~) (C++ :
, "", ..
). ,
.
,
(public).


(inheritance)
.
C++ :
class BaseClass // ()
{ };
class SubClass : public BaseClass // ()
{ };

SubClass BaseClass.
SubMyClass BaseClass,
(public, private, protected). , SubClass
, .
class BaseClass
{ };
class SubClass : public BaseClass
{ };

int fn(BaseClass _bc)


{
return 0;
}

void main(void)
{
int y;
BaseClass bc;

SubClass sc;
y = fn(bc);
y = fn(sc); // SubClass BaseClass
}

:
int fn(SubClass _sc)
{
return 0;
}

void main(void)
{
int y;
BaseClass bc;
SubClass sc;
y = fn(bc); // !
y = fn(sc);
}

BaseClass SubClass!
.
.NET-.
class MyPen : public Pen
{ };

,
:
(public)
,
.
(private)
( ).
(protected)
, .

( C++
, ,
. . " ").


,
,
( ).
:
class BaseClass
{
public:
BaseClass(int i)
{}
};

class SubClass : public BaseClass


{
public:

SubClass(int sc_i, int bc_i) : BaseClass(int bc_i)


{}
};

void main(void)
{
BaseClass bc(13);
SubClass sc(55, 4);
}

, ,
,
SubClass.


, . ,
, public.
, private protected.

public

protected

private



public
protected
private
public
protected
private
public
protected
private



public
protected

protected
protected

private
private

. -
,
( )
. ( )
, .
,
,
. ++ ,
, .
, - .
: MyClass::Fn(int, double).
. ,
- , -
?
class BaseClass //
{
public:
int fn() // BaseClass::fn()
{ return 0; }
};

class SubClass : public BaseClass //


{
public:
int fn() // SubClass::fn()
{ return 1; }
};


(overriding). ,
.
,
- ,
.
, , -
,
-
.
,

.
class BaseClass
{
public:
int fn()
{ return 0; }
};

class SubClass : public BaseClass


{
public:
int fn()
{ return 1; }
};

int _function(BaseClass& _bc)


{

return _bc.fn(); // ?
}

int main(void)
{
BaseClass bc;
SubClass sc;
_function(bc); // 0
_function(sc); // 0
return 0;
}

SubClass BaseClass.
_function() 0, ..
BaseClass::fn().
: _bc
BaseClass.
, C++ _function()
BaseClass.
_function() ,
_function(BaseClass) fn(BaseClass*) .
C++ .
.
, C++
.
. C++
,
( ) .
- ,
virtual.

.
. ,
.
class BaseClass
{
public:
virtual int fn()
{ return 0; }
};

class SubClass : public BaseClass


{
public:
virtual int fn()
{ return 1; }
};

int _function(BaseClass& _bc)


{
return _bc.fn();
}

int main(void)
{
BaseClass bc;
SubClass sc;

_function(bc); // 0
_function(sc); // 1
return 0;
}

_function() (bc)
BaseClass::fn(), 0.
_function () Subclass,
Subclass::fn(), 1.


, ,
- .
,
.
- ?
( ?)

? (
?)
?

? , -
, .
,
.


-, -
. -
, , ,
.

-,
,
.
:
void test(BaseClass b)
{
b.BaseClass::fn(); //
}

, .
,
. ,
- .
, ,
. ,
, .

.
,
. , ,
, , ,
:
class BaseClass //
{
public:
/*virtual*/ ~BaseClass() // BaseClass
{}
};

class SubClass : public BaseClass //


{
public:
~SubClass() // SubClass
{}
};

void main(void)
{
BaseClass* p_bc; // BaseClass
p_bc = new SubClass; // .. SubClass BaseClass
delete p_bc;
}

~BaseClass().
, SubClass,
p_bc, . ~BaseClass()
, .
:
.
, C++

! ,
,
.
,
( !): ,
,
.
, !



.
- .
:
class MyClass
{
public:
virtual void _function(int x) = 0; //
}

:
,
. :
.
,
.
; ,
.
.

(.. ).
.
,

.
class BaseClass //
{
public:

virtual void function_1() = 0;


virtual void function_2() = 0;
};

class SubClass1 : BaseClass // ( )


{
/* */
virtual void function_1();
virtual void function_2();
};

class SubClass2 : BaseClass // ()


{
/* */
virtual void function_2();
};

class SubClass3 : SubClass2 // ( )


{
/* SubClass2
SubClass3 ( ) */
virtual void function_1();
};

void fn(BzseClass* pBzseClass) //


// !

{}

void main(void)
{
SubClass1 sc1;
SubClass3 sc3;
fn(sc1); // SubClass1 BaseClass
}

,
,
. ,
, .
.



.
class BaseClass1
{
public:
int x;
int y;
};

class BaseClass2
{
public:
int x;
};

class SubClass : public BaseClass1, public BaseClass2


{
public:
/* */
};

,
.
. (BaseClass1
BaseClass2) - x. SubClass
BaseClass1::x BaseClass2::x.

x
, , x
.
void fn(void)
{
SubClass sc;
sc.x = 13; // !
}


.
void fn(void)
{
SubClass sc;
sc.BaseClass2::x = 13;
}


(. ).


virtual.
class Base
{
public:
Base() { }

int x;
};

class BaseClass1 : virtual public Base


{
public:
BaseClass1() { }
int y;
};

class BaseClass2 : virtual public Base


{
public:
BaseClass2() { }
int z;
};

class SubClass : public BaseClass1, public BaseClass2


{
public:
SubClass() : BaseClass1(),BaseClass2() { }
void _function(void);
/* */
};
void fn(void)

{
SubClass sc;
sc.x = 13;
}

SubClass Base ( x),


BaseClass1 BaseClass2 ( y z),
( _function()).
x fn() ,
SubClass Base.

1.
.
2.
.
3. -
, - .
4. , .

,
.

Оценить