• Access modifiers
• Anonymous classes
• this (a special pointer :))
• Static variables and methods
• Dynamic memory inside a class
• Constructors and destructors (including constructors for assignment and copying)
• struct and union (a comparison between C and C++)
• friend (a special access modifier)

Disclaimer

This tutorial is not for newbies/rookies. Although it begins with the basics, it is not intended as an exhaustive tutorial for first exposure to classes and C++. This tutorial is for people with some experience who would like to know the more interesting and esoteric stuff that there is to know. If you read on, you will probably find many things that are not in most C++ tutorials or you can find only in the thick books somewhere between the pages as well as many 'vaguely' explained areas of the language or areas that often cause confusion and tend to scare people away :). Questions or comments are welcome - email: litc1383 at dowling dot edu.

Introduction

Classes and objects are fundamental in Object-Oriented Programming (OOP). Classes in C++ are datatypes that consist of multiple components which can be eihter data of function. The functions of a class are called methods.A major characteristic that distinguishes classes from other data types is that they are not pre-defined, e.g. they are defined by the programmer himself according to his needs. This is equivalent to dynamically adding data types to the language. Is that cool or what :)

After a class is declared, it can be instantiated, you can create objects of that class. The difference between an object and a class is very important and very easy to understand - you can have only one class with a given name, but multiple objects of that class. Think of the class as the description of the object - the object should have such and such variables and methods. The object, on the other hand, is the flesh-and-blood realization of the defined class - it holds real values in these variables.

Class definition

The definition of a class consists of two parts: declaration of the class and definitions of its methods. Class declarations follow this sythax:

class[name of class] {
  components declaration
};

class Person {
  char name[20];
	unsigned age;
public;
  void GetData();
	void Display();
};

void Person::GetData() {
  cout << "Enter name: "; cin >> name; cout << '\n';
	cout << "Enter age: "; cin >> age; cout << '\n';
}

void Person::Display() {
  cout << "Name: " << name << "Age: " << age << '\n';
}

Person john, mary;

mary.GetData();
mary.Display();
john.GetData();

Access modifiers (component visibility)

The rules governing access to the data of a given class are different for the class's methods and external functions. This difference is very important: the methods of a class have full access to its components. Furthermore, you don't need to pass the variables of a class as parameters to the methods - they have priviliged access, known as 'direct access'. This is why GetData() and Display() did not take any arguments (in case you were wondering:)).
The access of external functions to a class's components depends on the the way the components were declared. Every component of a class be either private, public or protected. Members defined as private are visible only to the methods of that class and nobody else. By default the components of a class are private. That's why age and name are private and if you try to reference them directly, let's say like this

john.age = 10;

Pointers to objects. Arrays of objects. Dynamic creation of objects.

We can define pointers to objects just like we can do for any other data type:

Person *ptr;

Person george; //Create an object of the type Person
ptr = &george; //Assign ptr the address of george
(*ptr).GetData(); //Call george's GetData() method
(*ptr).Display(); //You should figure this one out by now

ptr->GetData();
ptr->Display();

Person *ptr;
ptr = new Person;
if(!ptr) { //Equivalent to if(ptr == NULL)
  cout << "Not enough memory";
}

if(!(ptr = new Person)) {
  cout << "Not enough memory";
}

delete ptr;

Person array[10];
array[3].GetData();
array[i].GetData();
(*(array+i)).GetData(); //Equivalent to the line above.

Anonymous Classes

C++ allows you to declare classes without names. Such classes are called anonymous. All methods of an anonymous class have to be defined inside the declaration of the class (e.g. they have to be inline functions). The reason for that is obvious - since the class has no name there is no way that we can tell the compiler which class we are refering to. Because of the same reason we have to declare the ojbects of the anonymous class in its definition (e.g. immediately after the '}' but before the semicolon ';'). Here's and example:

class {
  int x, y;
	char ss[20];
public:
  void Display() { cout << x << " " << y << " " << ss << '\n'; }
} obj1, obj2;

Objects as members of a class

It may come as a surprise to you but members of a class can be other objects as well, not just functions and variables. Here's an example:

class Person1 {
  char addr[20];
public:
  Person x;
	void GetAddress() {cout << "Enter address: "; cin >> addr; } //This is an inline method
	void DisplayAddress() { cout << "Address: " << addr;
};

y.x.GetData();
y.x.Display();
y.GetAddress();
y.DisplayAddress();

class List {
public:
  List item; //Error! Recursive declaration
	List *next; //This one's cool
};

The pointer this

When an object of a given class is created, the code for the methods of this class is not copied inside every object but rather stays at one location in memory. A resonable question is how do the methods of a class know which object exactly they were called and respectively the data of which object should they change or display? Here's the answer: when a method is called, besided the parameters specified in its declaration, there is one more parameter that's passed invisibly. This parameter is a pointer to the object that invoked the method and its name is this. this is a keyword in C++. Here's an example:

class cl {
 int x;
public:
  void increm() { x++; };
}

main() {
  cl obj1, obj2;
	obj1.increm();
	obj2.increm();
}

void increm() { (this->x)++; }

Static class components

Usually, every instance of a class has its own copies of the data members. However, sometimes it is necessary for all the objects to share one or more variables. For example one such variable could be the number of instances of the class. This effect is achieved through the use of static data (usually variables, but could also be objects).

To declare a member variable as static we use the static keyword. Static data members have the following idiosyncrasies:

• Memory for the static components of a class is allocated only once and all objects of that class have access to it
• Static data components are treated as external variables, hence they can be used stand-alone, not only in the context of an object. A static variable can be accessed from any function by using its full identifier, e.g. the class name, scope operator (::) and the name of the static variable. Here is an sample program where y is a static variable member of CL1:

class CL1 {
public:
  int x;
	static int y;
};

int CL1::y = 2; //NOTE that y has to be initialized before it can be used. Usually this is when memory is allocated.

main() {
  CL1 a, b;
	a.x = a.y = 3;
	cout << a.x << " " << a.y;
	b.y = 4;
	cout << a.y;
}

Static Methods

Classes can have not only static data but static methods as well. Unlike normal methods, static methods can be used stand-alone, not only in the context of an object. The stand-alone use of static methods requires the use of their full identifier (e.g. class name :: method name). Here is a sample static method f:

class X {
  int m;
public :
  static void f(int x, X *ptr); //Static method
};

...

void f2() {
  //Here we are calling an external function f, not f in the class X!!!
  f(1, &obj);
	
	//We call the static method f in X by using its full name
	CL1::f(1, &obj);
	
	//We call the static method f through an object - obj
	obj.f(1, &obj);
}