Machine Translated by Google

Computer Programming, Semester 3, Lecture No. 5, 18.11.2011

FRIENDSHIP
Familiarization is a method of breaking down encapsulation and objectivity. A given class / function / method
has full access to the friend class - including private elements. We define friending in a class sharing its
resources with a "friend".

void fun();

class B {
.
.
.
};

class C
{
public:
void met();
};

class A
{
private:
int a;

public:
friend void fun();
friend class B;
friend void C::met();
};

• Names must already be declared when using friend declarations. • Friendship is not transitive My
friend's friend is not my friend. • Friendship is not mutual - if class A is friends with class B, then class
B is NOT friends with class A. • Friendship is not hereditary - friend of my parents is not my friend.
Machine Translated by Google

class Four; // prototype

class point {

double x,y;

Public:
Point(double ax, double ay) {

x=ax;
y=ay;
}
...
friend int spr (Point &p, Four &c); // friend one function spr.
};

class Four {

double x1, y1, x2, y2;

};

int spr (Point &p, Quad &c ) {

if ((px >= c.x1) && (px <= c.x2) && (py >= p.y1) && (py <= c.y2))
returns 2;
else
return 0;
};

Thanks to friendship, only the spr function has access to data from the Point class.
Machine Translated by Google

class Four; // prototype int

class point {

double x,y;

Public:
Point(double ax, double ay) {

x=ax;
y=ay;
}
...
friend int Four::spr (Point &p,); // make friends with a particular method of one class.
};

class Four {

double x1, y1, x2, y2;

Four( double ax1, double ax2, double ay1, double ay2 ) { };

int spr (&p point) {

if ((px >= c.x1) && (px <= c.x2) && (py >= p.y1) && (py <= c.y2))
returns 2;
else
return 0;
};
};

Now the spr method of the Four class, and ONLY this method of this class can access the private data of the Point
class. Other methods from the Four class, as well as the Four class itself, have no access to the private data of the
Point class.
Machine Translated by Google

Two-way friendship

class two; // PROTOTYPE

friend class two;

second class
{
friend class one;
};

static, const, volatile modifiers

STATIC
Class A

{
static int a;

Public:
static int b;
void met()
{
a=10;
}
};

int A::a = 0;
intA::b=10;
// WHETHER A VARIABLE IS PRIVATE OR PUBLIC, IT CAN BE DECLARED.

A::ob.b = 4;
Aob1;

cout << ob1.b; // will print 4

STATIC VARIABLE IS ONE FOR ALL OBJECTS OF A GIVEN CLASS. THAT MEANS IF I CHANGE IT IN
ONE OBJECT, ALL OTHER OBJECTS OF THE CLASS WILL FEEL IT. THIS VARIABLE OCCUPATES ONE
SLOT IN MEMORY FOR ALL OBJECTS AT ONCE.

It's like a global variable, but when it's in a private section, only objects from that class can use it.

We can call a static method even if there are no objects of the class. For example, a static function, but we
can't use the this pointer in it because there is no object to point to.

CONST

const void print()

cout << b

void cos()

{
…

};

const ob.print();
ob.cos() // WRONG

VOLATILE

volatile int a;

This prohibits the compiler from optimizing the variable/object/function. Useful when some other
program wants to use our variable / object / function.

Modifiers are not resolved when using overloaded functions.

Example:
Machine Translated by Google

Class A

{
public
const int f(){...}
int f(){...}
// IT'S BAD...

THANKS TO ROLLING, YOU CAN GET RID OF MODIFIERS

{
int m;
Public:
const void fun 1()
{
m++ // error
}
const void fun2()
{
((X*)this)>m++; // THAT'S GOOD
...

OPERATORS
They can be defined in:
1) class method
2) global function

type...

operator @ (arg)
{
…

};

Use common sense - do not make operators, e.g. +, which subtract.

We can overload all operators except:

Only as methods we can overload operators:

() [ ] ÿ new delete (type, e.g. integer or something), ==

We cannot make operators from non-standard ASCI characters that are not normally used (heart, etc.). We
always define the operator for the argument to its left.

The operators += , + and = are 3 different operators, each defined separately. The same applies to other multi-
operand operators ( ==, <=, >=, etc.).

Defining operators in a class:

Class Point

double x,y;

Public:

int operator <= (Point &p)

if ((x<=px) && (y<=py))

return 1;
else

return 0;

};

point p1, p2;

int a = (p1<=p2); // 1 way

int a = p1.operator<=(p2); // 2nd way

Defining an operator as a global function. It is advisable to make friends of the function with the class to which the
operator will apply.
Machine Translated by Google

fun

int operator <=(point &p1, point &p2); // (left argument, right argument);
if ((p1x<=p2.x)&&(p1.y<=p2.y))
return 1;
else

return 0;

point p1, p2;

OPERATOR +

1) Global function

Operator point + (Point p, int l)

p.x+=1;
p.y+=l;
return p;
}

2) The method in the object

operator point + (int l)

point p = x this;
px += l;
py += l;
return p;
}

by Kozak127, IT, Rybnik