CLASSES AND OBJECTS

A class is a way to bind the data describing an

entity and its associated functions together. In

C++ , class makes a data type that is used to

create objects of this type.

Need for classes

Classes are needed to represent real-world

entities that not only have data type properties

(Characteristics) but also have associated

operations (their behaviour)

Class class_name

{

private:

data_members

member_functions

[public:

data_members

member_functions]

[protected:

data_members

member_functions]

}

Static Class Member In a class there may be static data member and static

functions member.

A static member variable has certain characteristics. These are :

It is initialized to zero when the first object of its class is created.

Only one copy of that member is created for the entire class and is shared by all the objects of that class, no matter how many objects are created.

It is visible only within the class, but its lifetime is the entire program.

Static variables are normally used to maintain values common to the entire class.

Static Member variable The declaration of a static data member in the member list of a class

is not a definition. You must define the static member outside of the class declaration because they are stored separately rather than as a part of an object. For example:

class X

{public:

static int i;

};

int X::i = 0; // definition outside class declaration

//int X::i;

//int X::i=10;

Also called as class variables.

Static Member Functions

A member function that is declared static has the

following properties:-

A static function can have access to only other static

members(functions or variables) declared in the same

class.

A static member function can be called using the class

name (instead of its objects) as follows:

class-name:: functionmame();

We can declare a static member by prefixing a word

static in front of the function return type

Scope of class and its Members-

The public member is the members that can be

directly accessed by any function, whether member

functions of the class or non member function of the

class.

The private member is the class members that are

hidden from outside class. The private members

implement the oop concept of data hiding. They are

only accessible through class member functions.

A class is known to be a global class if it defined outside the body of

function i.e. not within any function.

class cl { //* A class declared globally *//

….

};

cl ob; //global object

void main()

{

….

cl ob1; //local object of type cl

}

void function()

{

cl ob2; //local object of type cl

}

A class is known to be a local class if the definition of the class occurs inside (body) a function. For example

void main()

{Class cl { //* A class declared locally*//

….

}

cl ob;

}

void function(){

………

cl ob2; //invalid

}

In the above example the class ‘cl’ is available only within main() function therefore it can not be obtained in the function function().

A object is said to be a global object if it is declared outside all the function bodies it means the object is globally available to all the function in the code.

A global object can only be declared using global class type.

A object is said to be a local object if it is declared within the body of any function it means the object is available within the function and can not be used from other function.

A local object can be created from both class types : global as well as local.

my_class

{

int a;

public :void fn()

{

a=5;

cout<<”The answer is “<<a;

}

};

// * Global object *//

my_class ob1;

void kv()

{//* Local object *//

my_class ob2;

}

void main()

{ob1.read();

//* ob1 can be used as it is

global *//ob2.read();

//* ob2 can not be used as

it is local *//

}

Nested Classes When a class declared within another class then class declared within

(inside/inner class) is called ‘Nested class’ and the outer class is called ‘Enclosing class’.

class encl {

int a;class nest{

…

…

};

…

public :

int b;

};

In the given example ‘encl ‘ is an enclosing class and ‘nest’ is the nested class. The object of nested class can only be declared in enclosed class.

Object as Function Argument-

An object can be passed both ways:

i) By Value

When an object is passed by value, the function creates

its own copy of the object to work with it, so any

change occurs with the object within the function does

not reflect to the original object.

ii) By Reference

when we use pass by reference then the memory

address of the object passed to the function therefore

the called function is directly using the original object

and any change made within the function reflect the

original object.

class my_class {

public :

int a;

void by_value(my_class cv)

{ cv.a=cv.a+5;

cout<<"\n After pass by value";

}

void by_ref(my_class &cr)

{ cr.a=cr.a+5;

cout<<"\n After pass by reference";

}

void disp(my_class di)

{

cout<<"The result is "<<di.a;

}};

void main()

{ clrscr();

my_class ob,mc;

ob.a=12;

mc.by_value(ob);

mc.disp(ob);

mc.by_ref(ob);

mc.disp(ob);

getch();

}

Function Returning Object/ class type

function

To return an object from function we have

to declare the function return type as class

type .

For example my_class fn();

Here my_class is the class name and fn() is

the function name.

Constant Member Functions

If a member function of a class does not change any

data in the class then the member function can be

declared as constant member by post fixing the word

const at the time of function declaration.

Example- void fn() const;

Once a member function declared as const, it cannot

alter the data values of the class. Compiler will

generate error message.