Let's Practice Programming

Class Templates in C++

2021-02-04T20:48:00.004+05:30

Templates in C++ are of two types

2) Class Templates.

In this article we will learn about class templates.

Class templates are a way through which we can use the same class for different data types. You don't have to write classes with the same functionality again and again for different data types.

A difference between function templates and class templates is that the compiler cannot deduce the data types for the template parameters from the arguments provided by the user in the class template, so you have to explicitly specify the template arguments (data types to use) for the class template.

Defining a Class Template

Following is a basic example of a class template.

#include<iostream>
using namespace std;

template <typename T>    // template with single parameter T
class calci {
private:
	T first, second;  // two private variables of type T
public:
	calci(T var1, T var2) {      // a constructor with two parameters
		first = var1;        // assigning the argument values
		second = var2;	     // to the private variables
	}	
	T add() {			 // function definition which returns the
		return first + second;	 // the sum of the private variables
	}
	T subtract();		// declaring a function
};

template <typename T>		 // defining function outside the class
T calci<T>::subtract() {	 // provide template parameter of class template
	return first - second;	 // function returns the difference of the private variables
}

int main() {
	calci<int>obj1(10, 20);     // creating an object of class with template argument as "int"
	cout << obj1.add() << endl;	// calling function "add" through object
	cout << obj1.subtract() << endl; // calling function "subtract" through object
	
	calci<double>obj2(10.285, 20.267); // another object with template argument as "double"
	cout << obj2.add() << endl;		   // calling the functions from second object
	cout << obj2.subtract() << endl;
	return 0;
}

In the above example, from line 4, we define the class template. The definition starts with the keyword template and then in the angular brackets, another keyword typename (which can be substituted by keyword class) and then a placeholder for a data type where we have written T. You can anything instead of T.

We provide a single template parameter T, this T can indicate any data type the user provides as a template argument while creating an object from the class.

template <typename T>    // template with single parameter T

In the class named calci, we declare two private variables, first and second, they are of data type T (T indicates the data type specified by the user at the time of creating an object).

From line 9 we define a constructor (function with same name as of the class and which is executed automatically when an object is created) which is under public access specifier.

calci(T var1, T var2) {      // a constructor which takes two parameters
	first = var1;            // assigning the argument values
	second = var2;		// to the private variables
}

The constructor takes 2 arguments which will be passed when we create an object and assign the values of the arguments to the private variables.

Then from line 13, we define a function named add() which returns the sum of the two private variables first and second. The return type of the function is T.

Here the arguments are supposed to be numerical types (eg. int) or the types which can be converted to a numerical (eg. char).

T add() {	// function definition which returns the
	return first + second;	 // the sum of the private variables
}

On line 16, we declare a function named subtract() which will be defined outside the class.

T subtract();	// declaring a function subtract()

Now outside the class, from line 19, we use the function template format to define a function which was declared inside the class. We didn't use the template format for the function which was defined inside the class.

template <typename T>		 // defining a function outside the class
T calci<T>::subtract() {	 // provide template parameter of class template
	return first - second;	 // function returns the difference of the private variables
}

One thing to note in the second line of the above code is that we have to provide the template parameter just after the class name.

First we write the return type of the function that is T, then the class name followed by the template parameter (in this case <T>) and then we use the scope operator (::) to access the member function of the class. The substract() function returns the difference of the two private variables first and second.

Now in the main() function on line 25, we create an object named obj1.

calci<int>obj1(10, 20);     // creating an object of class "calci" with template parameter as "int"

As said, the compiler cannot deduce the data type for the template arguments from the arguments provided in a class template. Hence we have to explicitly specify the data type in the angle brackets just after class name (in this case <int>). And also we have to pass two arguments (int arguments) to the object (as the constructor of the class takes two arguments).

Then on line 26 and 27 we call the add() and subtract() function respectively through the object obj1.

cout << obj1.add() << endl;	// calling functions through object
cout << obj1.subtract() << endl;

Likewise on line 29, we create another object named obj2 of class calci. This time we specify the data type as double and pass two double arguments to the object. Also we call the add() and subtract() function through the object.

calci<double>obj2(10.285, 20.267); // another object with template argument as "double"
cout << obj2.add() << endl;		   // calling the functions from second object
cout << obj2.subtract() << endl;

Defining Class Template with multiple parameters

Below is an example of the a class template with multiple parameters.

#include<iostream>
using namespace std;

template <typename T, typename U>    // template with two parameters
class test {
private:
	T first;	// private member of type T
	U second;	// private member of type U
public:
	test(T var1, U var2);   // constructor declaration
	void show();		// function declaration
};
template <typename T, typename U>	// multiple parameter template format
test<T, U>::test(T var1, U var2) {	// defining the constructor with two different data type parameters
	first = var1;			// assigning the value of arguments to 
	second = var2;			// the private variables
}
template <typename T, typename U>	// defining function outside the class
void test<T, U>::show() {
	cout  << first << " and " << second << endl;  // has access to private members
}
int main() {
	test<int, string> obj1(10, "Hello World!");  // specifying data types when creating object 
				 // and also passing arguments
	obj1.show();		// calling function through object
	
	test<char, double> obj2('A', 2.3);	// another object with different template arguments
	obj2.show();
	return 0;
}

In above code, we define the class template from line 4, this time we have two template parameters T and U which indicate the data types specified by the user when we create an object of the class.

template <typename T, typename U>   // template with two parameters

The class is named as test. It has two private variables

private:
	T first;		// private member of type T
	U second;		// private member of type U

variable first is of type T and variable second is of type U.

Under the public access specifier, we declare a constructor which has two parameters of type T and U respectively. We also declare a function named show(). Both the constructor and the function are defined outside the class.

Because the constructor is defined outside the class, we have to write the function template format as from line 13.

template <typename T, typename U>   // multiple parameter template format
test<T, U>::test(T var1, U var2) {   // defining the constructor with two parameters
	first = var1;		// assigning the value of arguments to 
	second = var2;		// the private variables
}

And on the second line in the above code, we have to provide the template parameters after the class name (in this case <T, U>). Then we use the scope operator to access the constructor of the class. Here the constructor takes two parameters - var1 is of type T and var2 is of type U. The values of both the parameters are then assigned to the private variables first and second.

To define the function show() outside the class, again we write the function template format on line 18,

template <typename T, typename U>	// defining constructor outside the class
void test<T, U>::show() {
	cout  << first << " and " << second << endl;  // has access to private members
}

After that on the next line, we write the return type (in this case - void), then comes the class name. As said, we have to provide the template parameters in the angle brackets after the class name and then the scope operator followed by the function name.

This function prints the values of the private variables which were assigned the values of the arguments of the constructor.

Now in the main() function on line 23,

test<int, string> obj1(10, "Hello World!");  // specifying data types when creating object 
  		                // and also passing arguments
obj1.show();			// calling function through object

We create an object named obj1, of the class test. For that we need to write the class name, then in angular brackets, we provided the data types as template arguments of the class template (in this case <int, string>) and then a name for the object to be created. We also provide arguments for parameters to the constructor of the class.

Then on line 25, we call the function show() through the object obj1.

Likewise we create another object named obj2 on line 27, this time we pass the data types as <char, double>.

Default arguments in Class Templates

We shall modify the previous example a little bit to understand default parameters in class templates.

#include<iostream>
using namespace std;

template <typename T=int, typename U=string>   // specifying default parameters
class test {
private:	
	T first;
	U second;
public:
	test(T var1, U var2);
	void show();
};

template <typename T, typename U>
test<T, U>::test(T var1, U var2) {
	first = var1;
	second = var2;
}

template <typename T, typename U>
void test<T, U>::show() {
	cout  << first << " and " << second << endl;
}

int main() {

	test<> obj1(10, "Hello World!");    // empty angle brackets
	obj1.show();

	test<char, double> obj2('A', 2.3);
	obj2.show();

	return 0;
}

In the above program on line 4, we specify the default template parameters, T as int and U as double. If the template arguments passed are of the same type as the type of the default parameters respectively, the angular brackets can be empty while creating an object of the class.

And as you can notice on line 27, we kept the angular brackets empty because the types of the arguments passed are respectively the same as the default parameter types of the class template (in this case <int, string>).

test<> obj1(10, "Hello World!");    // empty angle brackets

But on line 30, while creating another object of the class, we specify the template arguments as they are different from the default arguments.

In this way we can use class templates in C++.

Function Templates In C++

2021-02-01T17:48:00.037+05:30

Templates are of two types.

1) Function Templates.

2) Class Templates.

In this article we will study about function templates.

Why Function Templates

Function templates are a simple and powerful feature of C++. They are a form of generic programming. They are generic because we don't need to specify the return type of the function and the data types of the variables and parameters used in the function at the time of defining it. We can use one function template for different data types.

Take a look at the following code.

// defining a function "add" which takes 2 integer parameters
// and returns their sum
int add(int var1, int var2) {        
	return  var1 + var2;
}

// defining a function with the same name "add" which takes
// two double parameters and returns their sum
double add(double var1, double var2) {
	return var1 + var2;
}

In the above code, we see function overloading (multiple functions with same name but with different arguments). Except the function return type and parameter data type everything is same.

Both the functions perform the same tasks i.e. adding values of two parameters except that the first function adds two integers and the second function adds two doubles.

In this situation we can use templates instead.

Creating a function template

// defining a function template
template<typename T>       // template takes one parameter for data type
T add(T var1, T var2) {    // function take two parameters and
	return var1 + var2;    // returns their sum
}

In the above code we created a function template. It starts with the keyword template and then in the angle brackets, another keyword typename (alias word for typename is class) and then a "placeholder" in which we have written T. T indicates the data type. You can write anything at the place of T. Here we have only one template parameter T.(we will see a template with multiple template parameters down in this article.

template<typename T>       // template takes one parameter for data type

As you can see on the next line, the return type of the function and the data type of its parameters is T. Here T can be any data type. T is a placeholder for the data type which is either deduced by the compiler from the arguments passed or is specified by the user at the time of calling this function.

We use the above template in the example below.

#include<iostream>
using namespace std;

// defining a function template
template <typename T>
T add(T var1, T var2) {
	return var1 + var2;
}


int main() {
	
	int int1 = 3, int2 = 5;         // defining two integers
	cout << add<int>(int1, int2) << endl; // specifying data type while calling the function
	cout << add(int1, int2) << endl;      // data type deduced by the compiler

	double dou1 = 3.9, dou2 = 4.5;   // defining 2 doubles
	cout << add<double>(dou1, dou2) << endl;   // specifying data type while calling the function
	cout << add(dou1, dou2) << endl;        // data type deduced by the compiler

	return 0;
}

In the above example, from line 5, we create the function template. As said the return type of the function and the data type of the parameters of the function, which will be decided when we call the function are indicated by T.

On line 13, we defined two integer variables and on line 14, we print the result of the call to the function by passing the two integers.

cout << add<int>(int1, int2) << endl; // specifying data type while calling the function

Here we explicitly specify the data type (<int>) in the angular brackets while calling the function. This means that all the Ts in the function template are replaced by int.

And on line 15, again we print the result of the call to the function by passing the two integers but this time we do not specify the data type, hence it is deduced by the compiler from the arguments provided.

cout << add(int1, int2) << endl;      // data type deduced by the compiler

Then on line 17, we defined two double variables, and on line 18,

cout << add<double>(dou1, dou2) << endl;   // specifying data type while calling the function

We specified the data type (<double>), hence all the Ts in the function will be replaced by double when we call that function.

And on line 19, we do not specify the data type, hence it is deduced by the compiler from the arguments provided.

Here in this function both the parameters passed to the function must be of the same type.

In the above function template, we passed only one parameter T for data type, we can pass multiple parameters.

Function template with multiple template parameters

In the following example,

// defining a function template with multiple parameters for data types
template <typename T, typename U>
U add(T var1, U var2) {           // return type is U
	return var1 + var2;
}

the function template has two template parameters and on the next line, the function takes two parameters of two different data types and returns their sum.

Note that in the above code, the return type of the function and the data type of the second parameter is same. We executed the above function template in the below code.

#include<iostream>
using namespace std;

// defining a function template with multiple parameters for data types
template <typename T, typename U>
U add(T var1, U var2) {           // return type is U
	return var1 + var2;
}

int main() {
	// defining one integer and one double
	int int1 = 4;
	double dou1 = 3.8;

	// specifying both data types
	cout << add<int, double>(int1, dou1) << endl;
	// data type deduced by the compiler
	cout << add(int1, dou1) << endl;

	return 0;
}

In the program above, from line 5, we create the function template.

On line 12 and 13, we define an integer and a double variable respectively.

On line 16,

cout << add<int, double>(int1, dou1) << endl;

We call the function by passing the integer and double variable as arguments and explicitly specifying the data types (<int, double>). Here we have to specify both the data types separated by a comma in the angular brackets.

On line 18, we do not specify the data types hence the compiler will deduce the data types from the arguments passed.

So in this way we can use one function template for different data types.

Classes & Objects In C++

2021-01-29T13:56:00.012+05:30

C++ is an object oriented programming language. Classes and objects are the way through which it implements its "object orientedness".

Classes are used to make user defined data types which we can use in our programs.

A class generally contains data members and member functions. A class is a blueprint from which any number of objects (which have certain attributes and functions) can be made. Data members (variables of class) are the attributes of the objects and member functions (functions declared / defined in the class) are the functions which define the behavior of the object.

Defining a Class

when a class is defined no memory is allocated. Memory is allocated for the object we create.

A class is used to make an object which resembles to real life objects. Following is a basic example of a class.

// person.h
#pragma once
using namespace std;
class person {	    // defining a class named "person"
public:			// public access specifier
	string name;		// two string variables 
	string gender;		// which are the attributes of the objects of this class.

	void speak();	// declaring the function which defines the behavior of the object
	
};

void person::speak() {	// defining "speak()" function
		// prints the name and gender of the person.
	cout << "My name is " << name << " and I am a " << gender << "." << endl;
}

Above is the header file in which, from line 4, we define a class named person.

Class definition starts with the keyword class. On line 5, we specify the public access_specifier and on line 6 and 7, (like a person has a name and a gender) we define two string variables, name and gender (attributes of the objects) which will respectively indicate the name and gender of the object created from the class person, simply said, when we create a person.

And as a person can speak, from line 9, we declare a function named speak(). This function does not return anything (void function) and does not take any parameters.

void speak();	// declaring the function which defines the behavior of the object

We define the speak() function outside the class, we did that by using the scope operator (::). On line 13, We first wrote the return type of the function, then the class name followed by the scope operator to access the member functions of the class, then comes the function body.

void person::speak() {		// defining a speak() function
		// prints the name and gender of the person.
	cout << "My name is " << name << " and I am a " << gender << "." << endl;
}

The function prints the value of the name and gender variables as if a person tells his/her name and gender.

In the above code we declared the speak() function inside the class and defined that function outside the class. If we were to directly define the speak() function inside the class, the code would have been like below.

// person_1.h
#pragma once
using namespace std;
class person {			// defining a class named "person"
public:				// public access specifier
	string name;		// two string variables 
	string gender;		// which are the attributes of the objects of this class.

	void speak() {		// defining a speak() function
			// prints the name and gender of the person.
		cout << "My name is " << name << " and I am a " << gender << "." << endl;
	}

};

Above is the header file in which we have directly defined the speak() function in the class from line 9.

void speak() {		// defining a speak() function
	// prints the name and gender of the person.
	cout << "My name is " << name << " and I am a " << gender << "." << endl;
}

Here we do not need to write the class name and the scope operator (::) before the function name.

Creating Objects from Class

Now, every time we create an object from a class, each object will have it's own copy of class members, in this case each object of the class person will have the name and gender variables and also the speak() function.

// program.cpp
#include<iostream>
#include "person.h"

using namespace std;

int main() {
	person obj1;           // creating a person
	obj1.name = "Jack";   // assigning value to string variable "name"
	obj1.gender = "Male";	// assigning value to string variable "gender" 
	obj1.speak();		// calling the speak function

	person obj2;		// same process for another person
	obj2.name = "Hallie";
	obj2.gender = "Female";
	obj2.speak();

	return 0;
}

To create an object, we specify the class name and the name for the object to be created. In the above code, on line 8, we created an object named obj1 of the class person.

As in the class, the string variables are public, so we can access those string variables through the object obj1 by using the dot operator (.).

obj1.name = "Jack";        // assigning value to string variable "name"
obj1.gender = "Male";      // assigning value to string variable "gender"

We assigned the value "Jack" to name variable and "Male" to gender variable and on line 11,

obj1.speak();	// calling the speak function

we call the speak() function which prints the value of both the string variables of the class.

Similarly on line 13, we create another object named obj2, and also assign values to the name and gender variable and then call the speak() function for obj2.

We can create as many objects we want and all will have their own attributes and functions.

Access Specifiers In C++

2021-01-23T05:07:00.013+05:30

There are 3 access specifiers which determine the accessibility / visibility of the class members.

Access Specifiers

1) public

2) private

3) protected

Let's take a look at an example.

// access_specifier.h
#pragma once
using namespace std;
class base {
// public members of the base class
public:
	void public_func() {
		cout << "Public member function in the base class.\n";
	}
// protected members of the base class
protected:
	void protected_func() {
		cout << "Protected member function in the base class.\n";
	}
// private members of the base class
private:
	void private_func() {
		cout << "Private member function in the base class.\n";
	}
};

In the above header file, we have defined a class named base. on line 6, we specified the "public" access specifier and under it, we defined a public function named public_func().

On line 11, we specified the "protected" access specifier and under it, we defined a protected function named protected_func().

On line 16, we specified the "private" access specifier and under it, we defined a private function named private_func().

Note :- If we do not specify any access specifier, then by default the members of the class are private.

// access_specifier.cpp
#include<iostream>
// Header file which contains the base and derived class
#include "access_specifier.h"
using namespace std;

int main() {
	base obj_b;              // creating an object of the base class
	obj_b.public_func();     // ok: accessing the public member of the base class
	obj_b.protected_func();  // error: accessing the protected member of the base class
	obj_b.private_func();    // error: accessing the private member of the base class
	return 0;
}

In the above code, on line 8, we made an object named obj_b of the base class.

base obj_b;              // creating an object of the base class

On line 9, we call the public function named public_func() through the object obj_b.

obj_b.public_func();     // ok: accessing the public member of the base class

But on line 10 and 11,

obj_b.protected_func();  // error: accessing the protected member of the base class

obj_b.private_func();  // error: accessing the private member of the base class

through the object obj_b, we try to access the functions protected_func() and private_func(), which are defined in the protected and private access specifiers respectively in the base class, which is an error because the protected members (except by the derived class) and private members of the base class cannot be accessed by code outside the class.

Although we can access the the protected and private members through a public function.

Lets look at an example.

// access_specifier.h
#pragma once
using namespace std;
class base {
public:
	void public_func() {
		cout << "Public member function in the base class.\n";
	}
	// public function that has access to the protected and private members of the base class
	void pro_pri_mem() {
		protected_func();
		private_func();
	}
protected:
	void protected_func() {
		cout << "Protected member function in the base class.\n";
	}
private:
	void private_func() {
		cout << "Private member function in the base class.\n";
	}
};

The members under the class have access to the other members of the class whether they are public, protected or private. So the public members can access the protected and private members of the class. Thus we can call the protected_func() and private_func() functions in pro_pri_mem() which is a public function.

// access_specifier.cpp
#include<iostream>
// Header file which contains the base and derived class
#include "access_specifier.h"
using namespace std;

int main() {
	base obj_b;              // creating an object of the base class
	obj_b.public_func();     // ok: accessing the public member of the base class
	obj_b.pro_pri_mem();	 // accessing the public function
	return 0;
}

In the above code on line 10, we call the pro_pri_mem() function which calls the protected and private functions of the class.

Inheritance and Access control

The access specifiers also play a role in inheritance (a class derived from a base class). They decide the visibility mode of the base class members for the derived class. A "derived class" can be inherited from "public", "protected" or "private" base class.

When a derived class is inherited from a public base class, the public and protected members of the base class are respectively the public and protected members of the derived class. The derived class cannot access the private members of the base class.

When a derived class is inherited from a protected base class, the public members and the protected members of the base class, both are protected members of the derived class. Here also, private members of the base class are not accessible in the derived class.

Finally if the derived class is inherited from a private base class, the public and protected members of the base class are private members of the derived class and the private members of the base class are not accessible in the derived class.

Let's see an example,

// access_specifier.h
#pragma once
using namespace std;
class base {
public:
	void public_func() {
		cout << "Public member function in the base class.\n";
	}
protected:
	void protected_func() {
		cout << "Protected member function in the base class.\n";
	}
private:
	void private_func() {
		cout << "Private member function in the base class.\n";
	}
};
// inheriting a derived class from a public base class
class derived_1 : public base {
public:
	void der_public_func_1() {    // defining public function
		public_func();	      // derived class can access public members of the base class
		protected_func();     // derived class can access protected members of the base class
	        private_func();	      // error: derived class cannot access private members of the base class
	}
};
// inheriting a derived class from a protected base class
class derived_2 : protected base {
public:
	void der_public_func_2() {    // defining public function
		public_func();	      // derived class can access public members of the base class
		protected_func();     // derived class can access protected members of the base class
	        private_func();	      // error: derived class cannot access private members of the base class
	}
};
// inheriting a derived class from a private base class
class derived_3 : private base {
public:
	void der_public_func_3() {    // defining public function
		public_func();	     // derived class can access public members of the base class
		protected_func();    // derived class can access protected members of the base class
	        private_func();	     // error: derived class cannot access private members of the base class
	}
};

In the above code we inherited 3 derived classes, on line 19, derived_1 was inherited from the public base class,

class derived_1 : public base {

on line 28 derived_2 was derived from the protected base class

class derived_2 : protected base {

and on line 37, derived_3 was inherited from the private base class.

class derived_3 : private base {

In each of the derived classes we define a public function in which we try to access the members inherited from the base class.

Since class derived_1 is inherited from a public base class, public_func() and protected_func() function members of the base class are also public and protected respectively in derived_1.

derived_2, is inherited from a protected base class, so both public_func() and protected_func() function members of the base class are protected in derived_2.

And derived_3 is inherited from a private base class, so both the public_func() and protected_func() function members of the base class are private in derived_3.

The derived classes cannot access the private_func() function member of the base class since it is a private member.

Let's see an example of this.

// access_specifier.cpp
#include<iostream>
#include "access_specifier.h"
using namespace std;

int main() {
	// object of the derived class inherited from public base class
	derived_1 derived_obj_1;		 
	// object of the derived class inherited from protected base class
	derived_2 derived_obj_2;		 
	// object of the derived class inherited from private base class
	derived_3 derived_obj_3;		 

	// public_func() is public as the derived class is inherited from the public base class
	derived_obj_1.public_func();	 
	// error: public_func() is protected as the derived class is inherited from the protected base class
	derived_obj_2.public_func();	 
	// error: public_func() is private as the derived class is inherited from the private base class
	derived_obj_3.public_func();	 

	return 0;
}

In the above code, on line 8, we created an object of class derived_1 which is inherited from public base class.

derived_1 derived_obj_1;

On line 10, we created an object of class derived_2 which is inherited from protected base class.

derived_2 derived_obj_2;

And on line 12, we created an object of class derived_3 which is inherited from private base class.

derived_3 derived_obj_3;

Now on line 15, we try to access public_func() through derived_obj_1 which is an object of class derived_1.

derived_obj_1.public_func();

Here public_func() is a public member of the class derived_1 as it is inherited from the public base class.

But on line 17, we try to access public_func() through derived_obj_2 which is an object of class derived_2.

derived_obj_2.public_func();

It is an error because here public_func() is protected member of class derived_2 as it is inherited from the protected base class.

Likewise on line 19, we try to access public_func() through derived_obj_3 which is an object of class derived_3.

derived_obj_3.public_func();

It is also an error because here public_func() is private member of class derived_3 as it is inherited from the private base class.

Namespaces in C++

2021-01-18T16:00:00.008+05:30

A namespace provides a scope in which its members (variables, functions, classes etc.) are declared/defined. C++ has many libraries and their might be a situation where one identifier(name of the variables, functions, classes etc.) in one library is same as another identifier in another library. Hence to avoid the name conflicts, we use namespaces.

Defining Namespaces

Lets take a basic example of a namespace.

#pragma once
using namespace std;
// Name of the namespace is demo
namespace demo {

	// defining a function named greet
	void greet() {
		cout << "Hello" << endl;
	}

	// defining a function named farewell
	void farewell() {
		cout << "Good Bye" << endl;
	}
}

Above is the header file in which we have defined a namespace named demo.

Namespace declaration starts with the keyword namespace and then the namespace name, in this case demo. In this namespace, we have defined two functions, first is greet(), which says "Hello", and second is farewell(), which says "Good Bye".

Suppose we hadn't defined the function in the namespace and their is another function named greet() in the huge C++ library (collection of code which make up the language), there would have been a name conflict, therefore we defined this function in namespace demo.

There are 3 ways through which we can access the members of a namespace

1. Using the fully qualified name

#include<iostream>
// including the header file which has the namespace
#include "namespaces.h"

using namespace std;

int main() {
	// using a qualified name to access the members of the namespace
	demo::greet();
	demo::farewell();
	return 0;
}

In the above example, we use the qualified name to access the member function of the demo namespace, on line 9 and 10.

demo::greet();
demo::farewell();

A fully qualified name is when we write the namespace name followed by the scope operator (::) followed by the name of the member you want to access. This way we have qualified access to the members of the namespace.

2. Using the "using" declaration to bring an individual identifier into scope.

#include<iostream>
// including the header file which has the namespace
#include "namespaces.h"

using namespace std;

int main() {
	// using the "using" declaration to bring
	// individual members into scope
	using demo::greet;
	using demo::farewell;

	greet();
	farewell();
	return 0;
}

In the above example on line 10 and 11,

using demo::greet;
using demo::farewell;

We brought both the member functions into scope individually, using the "using" declaration. This way is useful when we need one or two members of a namespace.

3. Using the "using" directive.

#include<iostream>
// including the header file which has the namespace
#include "namespaces.h"

using namespace std;
// using the "using" directive
using namespace demo;
int main() {

	greet();
	farewell();
	return 0;
}

In the above example, we used the "using" directive on line 7, which will bring all the members of the namespace into scope. This should be used when we use many of the namespace members.

We can define a namespace in multiple blocks in the same file and within multiple files, for example

// namespace_header.h
#pragma once

namespace demo {		// defining first block of namespace demo
	void greet() {
		std::cout << "Hello" << std::endl;
	}
}
/*
* 
* some code
* 
*/
namespace demo {		// definition continues in the second block
	void farewell() {
		std::cout << "Good Bye" << std::endl;
	}
}

In the above example the namespace demo is divided in two blocks and likewise it's parts can be defined in multiple files. Same is with namespace std, it is defined in many blocks in many header files in the C++ library.

Members declared in the namespaces can be defined outside the namespace through explicit qualification. But the definition of the member should come after the point of their declaration in the namespace.

#pragma once
using namespace std;
namespace demo {
    
    void greet();
}

// defining the declared function
void demo::greet() { cout << "Hello" << endl; } 
// error: farewell() is not a member of demo yet
void demo::farewell() { cout << "Goodbye" << endl; }

namespace demo {
    void farewell(); // declaring the member function
}

In the above example, function greet(), which is declared in the first block of namespace demo, is defined outside the namespace definition through explicit qualification. And on line 11, the function farewell() is defined through explicit qualification but the problem is at that point the function farewell() is not the part of the namespace demo, it is declared in the namespace demo, in its second block on line 14. So that becomes an error. The declaration and definition should be the correct order.

Global namespaces

An identifier which is not declared or defined in an any namespace, it is the part of the global namespace. Global namespace identifiers can be qualified by appending only the scope operator and no namespace name.

#include<iostream>
using namespace std;

int int1 = 1;	// variable defined in global namespace

int main() {
	// local variable in the main function
	int int1 = 2;
	
	// using the scope operator to access the global identifier
	::int1 = 2;

	return 0;
}

In the above example, on line 4, a global variable int1 is defined. Also in the main function, a variable named int1 is defined. Because the names are same, the global variable int1 is hidden in the main function, to use the global variable int1, we need to qualify the name being used that is, appending the scope operator (::) to the member name, there is no need of a namespace name. On line 11 we used a fully qualified name to access the global variable int1.

Let's look at Nested Namespaces

Nested namespace is a namespaces under a namespace. The code under parent namespace do not has unqualified access to child namespace's members, but the code in the child namespace has unqualified access (no need to append the namespace name and the scope operator to the members to be accessed) to the members of the parent namespace.

Below is an example.

#pragma once
// parent namespace
namespace parent {
	void func1() {			// function defined in parent namespace
		std::cout << "Welcome to the parent namespace THROUGH THE CHILD NAMESPACE."<< std::endl;
	}
	// child namespace
	namespace child {
		// function defined in the child namespace
		void func2() {
			// returns the result of a call to the function in the parent namespace
			return func1();	
		}
		void func3() {		// Another function in the child namespace
			std::cout << "This is the child namespace THROUGH THE PARENT NAMESPACE." << std::endl;
		}
	}
	void func4() {		// another function in the parent namespace
		// have to use the scope operator to access the child namespace members
		return child::func3();
	}
}

Namespace definition starts from line 3, that is the parent namespace, in which we defined function func1. From line 8, a namespace named child is defined.

In the child namespace a function named func2 is defined, which returns the result of the call to the function func1, which is defined in the parent namespace. Here the code in the child namespace has unqualified access to the members of the parent namespace.

From line 14, function func3 is defined, on line 17 child namespace definition completes. Now we are in the parent namespace, on line 18 function named func4 is defined which returns the result of the call to the function func3, which is defined in the child namespace. Here we have to use the qualified name to access the members of the child namespace.

There is a case when the members of the child namespace can be accessed without using the qualified name, that is when the child namespace is defined as inline.

Inline Namespaces

Following is the example of an inline nested namespace. The below example is same as the above example except on line 8, the child

#pragma once
// parent namespace
namespace parent {
	void func1() {			// function defined in parent namespace
		std::cout << "Welcome to the parent namespace THROUGH THE CHILD NAMESPACE."<< std::endl;
	}
	// child namespace defined as inline
	 inline namespace child {
		// function defined in the child namespace
		void func2() {
			// returns the result of a call to the function in the parent namespace
			return func1();	
		}
		void func3() {		// Another function in the child namespace
			std::cout << "This is the child namespace THROUGH THE PARENT NAMESPACE." << std::endl;
		}
	}
	void func4() {		// another function in the parent namespace
		// we don't have to use the scope operator to access the child namespace members
		return func3();
	}
}

namespace is defined as inline, and on line 20, the namespace name and the scope operator is gone, as the child namespace is defined as inline, the code in the parent namespace has unqualified access to the members of the child namespace.

Declaring and defining namespace members

One thing to keep in mind while "declaring" members in a namespace is when you define that very member at a different place you need to provide a fully qualified name even if you use the "using" directive.

Below is an example.

#pragma once
namespace demo {
	// just declaring the function greet
	void greet();
}

In above code, we have just declared a function in a namespace in a header file.

#include<iostream>
#include "namespace_header.h"

using namespace std;
// using directive to use the namespace demo
using namespace demo;

// To define the function we need a qualified name
void demo::greet() {
	cout << "Hello" << endl;
}

int main() {
	greet();
	return 0;
}

In the above example, on line 6 we using the "using" directive to bring into scope every thing in the namespace demo, despite that we have to use the qualified name to define the function greet() which was declared in namespace demo. If we didn't do this, the function greet(), will be an individual function having global scope and the compiler is confused between two overloaded functions (functions with same name), the first one is declared in the namespace and the second is the defined in the global namespace in the cpp file which is an error.

Namespace Aliases

#include<iostream>
using namespace std;

// namespace with a very big name
namespace this_is_the_namespace_name {
	void greet() {
		cout << "Hello" << endl;
	}
}

// alias for the big name
namespace NSName = this_is_the_namespace_name;

int main() {
	NSName::greet();
	return 0;
}

In the above example, namespace this_is_the_namespace_name is defined, as it is a very big name, on line 12 we made an alias for the namespace name.

namespace NSName = this_is_the_namespace_name;

Now instead of this_is_the_namespace_name we can write NSName. On line 15 we used the alias name to access the greet function.

Anonymous / unnamed namespaces

A namespace without a name is called anonymous or unnamed namespace. The anonymous namespace or its members are not visible to the code outside the file in which it is defined.

#include<iostream>
using namespace std;

// namespace with no name
namespace  {
	void greet() {
		cout << "Hello" << endl;
	}
}

int main() {
	greet();
	return 0;
}

In the above example, on line 5, their is no name for the namespace and also we don't need the qualified access to the members.

References :- https://docs.microsoft.com/en-us/cpp/cpp/namespaces-cpp

Header Files in C++

2021-01-14T00:20:00.013+05:30

So header files in C++ are files which contain code such as classes, functions, structs....

In every C++ program we have seen the "iostream" header file, this header file contains objects like cin and cout which handle input and output respectively. There are many standard library header files such as iostream. Others are the user defined header files which we make to have our own code.

The benefit of a header file is that once we write, for example a 100 line code and we need that code in many of your programs, (just as to use the cin and cout objects we use the "iostream" header) it is cumbersome to write that 100 line code again and again, so we write that code in a header file and just use the header file to get the 100 line code in each of our programs.

To use the header file, we write "#include", which is a preprocessor directive that will first process the code in the header file and then the code in the file in which the header file is used.

Making a Header File

In C the header files end with the .h extension, in C++ the standard library files don't have the .h extension but the user defined header files in C++ have to have the .h extension. We can use the C libraries in C++ by excluding the .h extension and putting a 'c' before the library name. for example - <stdio.h> in C becomes <cstdio> in C++.

Let's look at a basic example of a header file.

 // demoHeader.h
 // A header file

 #pragma once		// preprocessor directive to include the file only once
 using namespace std;
 // function to convert lowercase letters of a string to uppercase

 string low_to_up(string str1) {		    // function header
	 for (int i = 0; i != str1.size(); ++i) {   // using the traditional for loop 
						   // to go through each character in the string.
		 str1[i] = toupper(str1[i]);	   // Making each character uppercase
	 }
	 return str1;				   // returning the modified string
 }

On line 3,

#pragma once	// preprocessor directive to include the file only once

"#pragma once" is a preprocessor directive, which tells the compiler to include the code of the header file only once. This is necessary to not repeat the code. Repeating the code may cause errors and to avoid this, we use "#pragma once".

Then from line 8, we define a function named low_to_up which returns a string and takes a string parameter.

string low_to_up(string str1) {		// function header

Line 9 states the for loop header,

for (int i = 0; i != str1.size(); ++i) {    // using the traditional for loop to go 
					    // through each character in the string.

The for loop traverses through all the characters in the string, each character is converted to uppercase on line 11.

str1[i] = toupper(str1[i]);		// Making each character uppercase

When all the characters are finished processing, the for loop ends and then, we return the modified string.

return str1;	    // returning the modified string

That was the header file, now we write the main cpp file,

Including the header file

 // program.cpp

 #include<iostream>				// standard library header file
 #include "demoHeader.h"			// user defined header file

 using namespace std;

 int main() {
	
	 string text = "abcdefghijklmnopqrstuvwxyz";	// Initializing a string variable
	 cout << text << endl;
	 text =  low_to_up(text);	// assigning the return value of the low_to_up function
					// to the variable name
	 cout << text << endl;	    // printing the modified value.

	 return 0;
 }

At line 3 is the standard library file (<iostream>) and at line 4 is the use defined header file which we just made.

#include<iostream>		// standard library header file
#include "demoHeader.h"		// user defined header file

The name of the header file should be in double quotes, preceded by the preprocessor directive "#include".

On line 10, we define a string variable named as text, which is assigned a string literal.

string text = "abcdefghijklmnopqrstuvwxyz";	// Initializing a string variable

On line 11, we simply print the value of variable text.

On line 12, we assign to text the result of the call to the function low_to_up, with text being its parameter. The function converts the string to uppercase and assigns its return value to text, then again on line 14, we print the value of text.

The result is

abcdefghijklmnopqrstuvwxyz

ABCDEFGHIJKLMNOPQRSTUVWXYZ

So, we wrote the function in the header file and just used the header file in the main cpp file with the help of the preprocessor directive. Like wise if we want to use that function in any other program we make, we don't have to write the full function code, just have to use the header file.

Top Level and Low Level Const in C++

2021-01-13T15:37:00.003+05:30

Let's look at an example..

  #include<iostream>
  using namespace std;

  int main() {
  	  int int1 = 1, int2 = 2;       // Defining two integer variables
	  int* const ptr1 = &int1;      // ptr1 has a top - level const
	  // ptr1 is a constant pointer to integer variable int1

	  ptr1 = &int2;                 // error : we cannot assign the address of any other variable to ptr1
	  *ptr1 = 3;                    // we can change the value of int1 through ptr1
	  const int* ptr2 = &int1;      // ptr2 has a low level const
	  // ptr2 is a pointer to a constant integer

	  *ptr2 = 3;                    // error : we cannot change the value of int1 through ptr2
	  ptr2 = &int2;                 // we can assign address of another variable to ptr2, now ptr2 points to int2
	  const int* const ptr3 = &int1;  // here ptr3 has both top level and low level const

	  const int int3 = 3;	        // Defining a constant integer variable int3, here int3 has a top level const
	  const int* ptr4 = &int3;	// ptr4 is a pointer to a constant integer, here ptr4 has a low level const

	  return 0;
  }

In the above example, on line 5 we defined two integer variables

int int1 = 1, int2 = 2;         // Defining two integer variables

on line 6, we define ptr1 which is a constant pointer to an integer and it is assigned the address of int1.

int* const ptr1 = &int1;        // ptr1 has a top - level const

Here ptr1 has a top level const, that means we cannot assign an address of some other variable to it.

On line 9 we try to assign the address of int2 to ptr1,

 ptr1 = &int2;  // error : we cannot assign the address of any other variable to ptr1

which is an error because ptr1 is a constant pointer to int1. Although we can change the value of int1 through ptr1.

*ptr1 = 3;     // we can change the value of int1 through ptr1

On line 11. we define ptr2, which is a pointer to a constant integer and is also assigned the address of int1. Here ptr2 has a low level const. Although int1 is not a constant, the definition means that we cannot change the value of int1 through ptr2.

const int* ptr2 = &int1;    // ptr2 has a low level const
// ptr2 is a pointer to a constant integer

On line 14, we try to change the value of int1 through ptr2,

*ptr2 = 3;   // error : we cannot change the value of int1 through ptr2

that's an error because ptr2 is a pointer to constant integer. we can assign the address of another variable to ptr2.

ptr2 = &int2;      // we can assign address of another variable to ptr2,
                   // now ptr2 points to int2

On line 16, we define ptr3, which is a constant pointer to constant integer.

const int* const ptr3 = &int1;  // here ptr3 has both top level and low level const

Here, ptr3 which is also assigned the address of int1, has both top level and low level const, that means neither we can assign a different address to ptr3, nor we can change the value of the variable ptr3 is pointing to.

Now, at line 18 we defined a constant int named int3.

const int int3 = 3;	// Defining a constant integer variable int3, here int3 has a top level const

int3 is a constant, so it's value cannot be changed.

On line 19, we defined a pointer to a constant integer named ptr4, it is pointing towards a constant integer, that's why is has a low level const, otherwise it would have been an error.