The Eduladder is a community of students, teachers, and programmers just interested to make you pass any exams. So we help you to solve your academic and programming questions fast.
In eduladder you can Ask,Answer,Listen,Earn and Download Questions and Question papers.
Watch related videos of your favorite subject.
Connect with students from different parts of the world.
Apply or Post Jobs, Courses ,Internships and Volunteering opportunity. For FREE
See Our team
Wondering how we keep quality?
Got unsolved questions? Ask Questions


You are here:Open notes-->VTU-->Object-oriented-programming-with-c10CS36-unit-2

Object oriented programming with c++[10CS36] unit-2

UNIT II CLASSES AND OBJECTS I

Topics covered

Classes & Objects I: Class Specification, Class Objects, Scope resolution operator, Access members, Defining member functions, Data hiding, Constructors, Destructors, Parameterized constructors, Static data members, Functions

UNIT-2 Summary

In C++, the class forms the basis for object-oriented programming. The class is used to define the nature of an object, and it is C++'s basic unit of encapsulation. This chapter examines classes and objects in detail.

1. Class Specification

Classes are created using the keyword class. A class declaration defines a new type that links code and data. This new type is then used to declare objects of that class. Thus, a class is a logical abstraction, but an object has physical existence. In other words, an object is an instance of a class.

A class declaration is similar syntactically to a structure. a simplified general form of a class declaration was shown. Here is the entire general form of a class declaration that does not inherit any other class.

class class-name {

private data and functions

access-specifier:

data and functions

access-specifier:

data and functions

// ...

access-specifier:

data and functions

} object-list

The object-list is optional. If present, it declares objects of the class. Here, access-specifier is one of these three C++ keywords:

public

private

protected

class employee {

char name[80];

double wage;

public:

void putname(char *n);

void getname(char *n);

void putwage(double w);

double getwage();

};

Functions that are declared within a class are called member functions. Member functions may access any element of the class of which they are a part. This includes all private elements. Variables that are elements of a class are called member variables or data members. (The term instance variable is also used.) Collectively, any element of a class can be referred to as a member of that class. There are a few restrictions that apply to class members. A non-static member variable cannot have an initializer. No member can be an object of the class that is being declared.

(Although a member can be a pointer to the class that is being declared.) No member can be declared as auto, extern, or register. In general, you should make all data members of a class private to that class. This is part of the way that encapsulation is achieved. However, there may be situations in which you will need to make one or more variables public.

(For example, a heavily used variable may need to be accessible globally in order to achieve faster run times.) When a variable is public, it may be accessed directly by any other part of your program. The syntax for accessing a public data member is the same as for calling a member function: Specify the object's name, the dot operator, and the variable name. This simple program illustrates the use of a public variable:

2. Class Objects

#include

using namespace std;

class myclass {

public:

int i, j, k; // accessible to entire program

};

int main()

{

myclass a, b;

a.i = 100; // access to i, j, and k is OK

a.j = 4;

a.k = a.i * a.j;

b.k = 12; // remember, a.k and b.k are different

cout << a.k << " " << b.k;

return 0;

}

3. Scope resolution operator

As you know, the :: operator links a class name with a member name in order to tell the compiler what class the member belongs to. However, the scope resolution operator has another related use: it can allow access to a name in an enclosing scope that is "hidden" by a local declaration of the same name. For example, consider this fragment:

int i; // global i

void f()

{

int i; // local i

i = 10; // uses local i

}

As the comment suggests, the assignment i = 10 refers to the local i. But what if

function f( ) needs to access the global version of i? It may do so by preceding the

i with the :: operator, as shown here.

int i; // global i

void f()

{

int i; // local i

::i = 10; // now refers to global i

}

4. Access members

By default, functions and data declared within a class are private to that class and may be accessed only by other members of the class. The public access specifier allows functions or data to be accessible to other parts of your program. The protected access specifier is needed only when inheritance is involved. Once an access specifier has been used, it remains in effect until either another access specifier is encountered or the end of the class declaration is reached. You may change access specifications as often as you like within a class declaration. For example, you may switch to public for some declarations and then switch back to private again. The class declaration in the following example illustrates this feature:

5. Constructors

Constructors are special member functions that are executed whenever we create new objects of a class type. The job of a constructor is to ensure that the data members of each object start out with sensible initial values. If a constructor only has one parameter, there is a third way to pass an initial value to that constructor. For example, consider the following short program.

#include

using namespace std;

class X {

int a;

public:

X(int j) { a = j; }

int geta() { return a; }

};

int main()

{

X ob = 99; // passes 99 to j

cout << ob.geta(); // outputs 99

return 0;

}

Here, the constructor for X takes one parameter. Pay special attention to how ob is declared in main( ). In this form of initialization, 99 is automatically passed to the j parameter in the X( ) constructor. That is, the declaration statement is handled by the compiler as if it were written like this:

X ob = X(99);

In general, any time you have a constructor that requires only one argument, you can use either ob(i) or ob = i to initialize an object. The reason for this is that whenever you create a constructor that takes one argument, you are also implicitly creating a conversion from the type of that argument to the type of the class. Remember that the alternative shown here applies only to constructors that have exactly one parameter.

6. Destructors

One purpose of a constructor is to provide for the automatic acquisition of a resource. For example, a constructor might allocate a buffer or open a file. Having allocated the resource in the constructor, we need a corresponding operation that automatically deallocates or otherwise releases the resource. The destructor is a special member function that can be used to do whatever resource deallocation is needed. It serves as the complement to the constructors of the class.

When a Destructor Is Called

The destructor is called automatically whenever an object of its class is destroyed:

// p points to default constructed object

Sales_item *p = new Sales_item;

{

// new scope

Sales_item item(*p); // copy constructor copies *p into item

delete p; // destructor called on object pointed to by p

} // exit local scope; destructor called on item

Variables such as item are destroyed automatically when they go out of scope. Hence, the destructor on item is run when the close curly is encountered. An object that is dynamically allocated is destroyed only when a pointer pointing to the object is delete d. If we do not delete a pointer to a dynamically allocated object, then the destructor is never run on that object. The object will persist forever, leading to a memory leak. Moreover, any resources used inside the object will also not be released.

7. Parameterized constructors

It is possible to pass arguments to constructors. Typically, these arguments help initialize an object when it is created. To create a parameterized constructor, simply add parameters to it the way you would to any other function. When you define the constructor's body, use the parameters to initialize the object. For example, here is a simple class that includes a parameterized constructor:

#include

using namespace std;

class myclass {

int a, b;

public:

myclass(int i, int j) {a=i; b=j;}

void show() {cout << a << " " << b;}

};

int main()

{

myclass ob(3, 5);

ob.show();

return 0;

}

Notice that in the definition of myclass( ), the parameters i and j are used to give initial values to a and b. The program illustrates the most common way to specify arguments when you declare an object that uses a parameterized constructor. Specifically, this statement myclass ob(3, 4); causes an object called ob to be created and passes the arguments 3 and 4 to the i and j parameters of myclass( ). You may also pass arguments using this type of declaration statement:

myclass ob = myclass(3, 4);

However, the first method is the one generally used, and this is the approach taken by most of the examples in this book. Actually, there is a small technical difference between the two types of declarations that relates to copy constructors. Here is another example that uses a parameterized constructor. It creates a class that stores information about library books.

#include

#include

using namespace std;

const int IN = 1;

const int CHECKED_OUT = 0;

class book {

char author[40];

char title[40];

int status;

public:

book(char *n, char *t, int s);

int get_status() {return status;}

void set_status(int s) {status = s;}

void show();

};

book::book(char *n, char *t, int s)

{

strcpy(author, n);

strcpy(title, t);

status = s;

}

void book::show()

{

cout << title << " by " << author;

cout << " is ";

if(status==IN) cout << "in.\n";

else cout << "out.\n";

}

int main()

{

book b1("Twain", "Tom Sawyer", IN);

book b2("Melville", "Moby Dick", CHECKED_OUT);

b1.show();

b2.show();

return 0;

}

Parameterized constructors are very useful because they allow you to avoid having to make an additional function call simply to initialize one or more variables in an object. Each function call you can avoid makes your program more efficient. Also, notice that the short get_status( ) and set_status( ) functions are defined in line, within the book class. This is a common practice when writing C++ programs.

8. Static data members

When you precede a member variable's declaration with static, you are telling the compiler that only one copy of that variable will exist and that all objects of the class will share that variable. Unlike regular data members, individual copies of a static member variable are not made for each object. No matter how many objects of a class are created, only one copy of a static data member exists. Thus, all objects of that class use that same variable. All static variables are initialized to zero before the first object is created.

When you declare a static data member within a class, you are not defining it. (That is, you are not allocating storage for it.) Instead, you must provide a global definition for it elsewhere, outside the class. This is done by redeclaring the static variable using the scope resolution operator to identify the class to which it belongs. This causes storage for the variable to be allocated. (Remember, a class declaration is simply a logical construct that does not have physical reality.) To understand the usage and effect of a static data member, consider this program:

#include

using namespace std;

class shared {

static int a;

int b;

public:

void set(int i, int j) {a=i; b=j;}

void show();

} ;

int shared::a; // define a

void shared::show()

{

cout << "This is static a: " << a;

cout << "\nThis is non-static b: " << b;

cout << "\n";

}

int main()

{

shared x, y;

x.set(1, 1); // set a to 1

x.show();

y.set(2, 2); // change a to 2

y.show();

x.show(); /* Here, a has been changed for both x and y

because a is shared by both objects. */

return 0;

}

This program displays the following output when run.

This is static a: 1

This is non-static b: 1

This is static a: 2

This is non-static b: 2

This is static a: 2

This is non-static b: 1

9. Static Member Functions

Member functions may also be declared as static. There are several restrictions placed on static member functions. They may only directly refer to other static members of the class. (Of course, global functions and data may be accessed by static member functions.) A static member function does not have a this pointer. There cannot be a static and a non-static version of the same function. A static member function may not be virtual. Finally, they cannot be declared as const or volatile. Following is a slightly reworked version of the sharedresource program from the previous section. Notice that get_resource( ) is now declared as static. As the program illustrates, get_resource( ) may be called either by itself, independently of any object, by using the class name and the scope resolution operator, or in connection with an object

#include

using namespace std;

class cl {

static int resource;

public:

static int get_resource();

void free_resource() { resource = 0; }

};

int cl::resource; // define resource

int cl::get_resource()

{

if(resource) return 0; // resource already in use

else {

resource = 1;

return 1; // resource allocated to this object

}

}

int main()

{

cl ob1, ob2;

/* get_resource() is static so may be called independent

of any object. */

if(cl::get_resource()) cout << "ob1 has resource\n";

if(!cl::get_resource()) cout << "ob2 denied resource\n";

ob1.free_resource();

if(ob2.get_resource()) // can still call using object syntax

cout << "ob2 can now use resource\n";

return 0; }

Actually, static member functions have limited applications, but one good use for them is to "preinitialize" private static data before any object is actually created. For example, this is a perfectly valid C++ program:

#include

using namespace std;

class static_type {

static int i;

public:

static void init(int x) {i = x;}

void show() {cout << i;}

};

int static_type::i; // define i

int main()

{

// init static data before object creation

static_type::init(100);

static_type x;

x.show(); // displays 100

return 0;

}


Editors




You might like this video:Watch more here

Watch more videos from this user Here

Learn how to upload a video and start earning here