C++ Support for Code Writing

We have been introduced to declaring variables using specific data types. After declaring a value and initializing it, you may want the value to change type without redefining it. This is required in some cases where you already have a value, probably produced by one variable, while another variable declared with a different data type. This means that you would need to convert a value from one type into another type. For example, you may have declared a variable using a double data type but you need the value of that variable to be used as an int. Transferring a value from one type to another is referred to as casting.

There are two broad types of casting available in C++: C's old school of casting and the C++ standards.

C, the parent of C++ supports value casting by specifying the type of value you want an existing one to have. To do this, you use the following formula:

(DataType)Expression

Based on this formula, in the parentheses, enter the type of data you want the existing or resulting value to have. The DataType factor can be any of the data types we saw above. The Expression factor can be a constant value. Here is an example:

#include <iostream>
using namespace std;

int main()
{
	cout << "Number: " << (int)3.14159 << "\n";

	return 0;
}

Notice that the value to convert is a floating-point number. If the conversion is successful, the new value would be conform to the type in parentheses. For example, the above code would produce:

Number: 3

Here is another version of the above program:

#include <iostream>
using namespace std;

int main()
{
	int number;

	number = (int)3.14159;

	cout << "Number: " << number << "\n";

	return 0;
}

The Expression factor can also be the result of a calculation. In this case, you should include the whole expression is its own parentheses.

The Expression factor of our formula can also be the name of a variable that holds a value. Here is an example:

#include <iostream>
using namespace std;

int main()
{
	double price = 258.85;
	int number;

	cout << "Price? $" << price << "\n";

	number = (int)price;

	cout << "Number: " << number << "\n";

	return 0;
}

This would produce:

Price? $258.85

Number: 258

C++ provides its own support of value casting using variable keywords so you can specify the type of conversion you want. One of the keywords used is static_cast and the formula is:

static_cast<DataType>(Expression)

In this formula, the static_cast keyword, the <, the >, and the parentheses are required. The DataType factor should be an existing data type such as those we have reviewed in this lesson. The Expression factor can be a constant value. Here is an example that converts a floating-point number to an integer:

#include <iostream>

using namespace std;



int main()

{

	cout << "Number: " << static_cast<int>(3.14159) << "\n";



	return 0;

}

You can also assign the resulting value to a variable before using it:

#include <iostream>

using namespace std;



int main()

{

	int number = static_cast<int>(3.14159);



	cout << "Number: " << number << "\n";



	return 0;

}

The value to convert can also be the result of a calculation. The value can also be originating from an existing variable whose value you want to convert to a new type. Here is an example:

#include <iostream>

using namespace std;



int main()

{

	double PI = 3.14159;

	int number;

	

	number = static_cast<int>(PI);



	cout << "PI = " << PI << endl;

	cout << "Number = " << number << "\n";



	return 0;

}

This would produce:

PI = 3.14159

Number = 3

So far, to declare a variable, we proceeded inside of the main() function. Such a variable could be used only inside of the square brackets of main(). In some cases, you may want to declare a variable that can be accessed from one section of the code. The section of code in which a variable can be accessed is referred to as its scope.

If you declare a variable inside of a function such as main(), that function can be accessed only from that function. Consider the following example:

#include <iostream>

using namespace std;



int main()

{

	double number = 3.14159;

	cout << "Number = " << number << "\n";

	

	return 0;

}

Such a variable is referred to as local because it is declared in a function. In reality, a local scope is defined by a beginning opening curly bracket "{" and a closing curly bracket "}". Everything between these brackets belongs to a local scope.

Once you have declared such a variable, you cannot declare another variable in the same scope and that bears the same name. Consider the following example:

#include <iostream>

using namespace std;



int main()

{

	double number = 3.14159;

	cout << "Number = " << number << "\n";



	double number = 2.98;

	cout << "Number = " << number << "\n";

	

	return 0;

}

This would produce a "redefinition" error and the program would not compile, even if the second declaration uses a different data type. As one type of solution to this kind of problem, C++ allows you to create a "physical" scope. To do this, you can use curly brackets to delimit the scope of a particular variable. Here is an example:

#include <iostream>

using namespace std;



int main()

{

	{

		double number = 3.14159;

		cout << "Number = " << number << "\n";

	}

	

	double number = 2.98;

	cout << "Number = " << number << "\n";



	return 0;

}

This would produce:

Number = 3.14159

Number = 2.98

In the code, notice that we delimit only the first declaration. Indeed, you can delimit each scope if you want:

#include <iostream>

using namespace std;



int main()

{

	{

		double number = 3.14159;

		cout << "Number = " << number << "\n";

	}

	

	{

		double number = 2.98;

		cout << "Number = " << number << "\n";

	}



	return 0;

}

Global Variables

C++ allows you to declare a variable outside of any function. Such as a variable is referred to as a global variable (). To declare a global variable, proceed as you normally would. Here is an example:

#include <iostream>

using namespace std;



double number;



int main()

{



	return 0;

}

After declaring the variable, you can initialize it immediately:

#include <iostream>

using namespace std;



double number = 3.14159;



int main()

{

	cout << "Number = " << number << "\n";



	return 0;

}

You can also initialize it inside of the function that would use it. After declaring and initializing the variable, you can access its value and use it. For example, you can display its value to the user. Here is an example:

#include <iostream>

using namespace std;



double number;



int main()

{

	number = 3.14159;



	cout << "Number = " << number << "\n";



	return 0;

}

In C++ (some other languages don't have this situation), the compiler always proceed in a top-down approach. After declaring a variable, only the sections under it can access it. This means that you cannot access a variable above its declaration. Consider the following program where only the area of the declaration has changed:

#include <iostream>

using namespace std;



int main()

{

	number = 3.14159;



	cout << "Number = " << number << "\n";



	return 0;

}



double number;

 This program would not compile. The reason is that, when accessing it inside of main(), as far as main() is concerned, the variable has never been declared and C++ doesn't allow the use of a variable before it has been declared. Therefore, you must always declare a variable before accessing it.

Namespaces

Introduction

A namespace is a section of code, delimited and referred to using a specific name. A namespace is created to set apart a portion of code with the goal to reduce, otherwise eliminate, confusion. This is done by giving a common name to that portion of code so that, when referring to it, only entities that are part of that section would be recognized.

A namespace is not a variable. It is not a function. It is not a class. It is only a technique of naming a section of code and referring to that section of code with a name.

Creating a namespace

The syntax of creating a namespace is:

namespace Name { Body }

The creation of a namespace starts with the (required) namespace keyword followed by a name that would identify the section of code. The name follows the rules we have been applying to C++ names except that, throughout this site, the name of a namespace will start in uppercase.

A namespace has a body: this is where the entities that are part of the namespace would be declared or defined. The body of the namespace starts with an opening curly bracket “{” and ends with a closing curly bracket “}”. Here is an example of a simple namespace:

namespace Mine

{

    int a;

}

The entities included in the body of a namespace are referred to as its members. 

Accessing a namespace: The Scope Access Operator

To access a member of a namespace, there are various techniques you can use. The scope access operator “::” is used to access the members of a namespace. To do this, type the name of the namespace, followed by the scope access operator “::”, followed by the member you are want to access. Only the members of a particular namespace are available when using its name. For example, to access the member “a” of the Mine namespace above, you can write:

Mine::a;

Once you have access to a namespace member, you can initialize it or display its value using cout. Here is an example:

This would produce:

Value of a = 140

When creating a namespace, you can add as many members as you see fit. When necessary, you can use the scope access operator "::" to call anyone of them as needed. Here is an example: 

You can also request the values of the members of a namespace from the user. Remember to use the scope access operator "::" whenever you need to access the member of a namespace. Here is an example:

The member variable of a namespace can also be mixed with a variable that is locally declared in a function. All you have to do is make sure that you qualify the member of the namespace so the compiler would be able to locate it. Here is an example: 

The using Keyword

The scope access operator “::”provides a safe mechanism to access the members of a namespace. If the namespace is very long and the application needs constant access, this might be a little cumbersome. Another technique used to access the members of a namespace involves using two keywords: using and namespace. 

To call a namespace, on the section of the program where you need to access the members, type:

using namespace NamespaceName;

Both the using and the namespace keywords are required by the compiler. The NamespaceName represents the name of the namespace whose member(s) you want to access. Using this technique, the above program can be written:

In a variable intensive program (we are still inside of one function only) where a local variable holds the same name as the member of a namespace that is being accessed with the using namespace routine, you will be sensitive to the calling of the same name variable. When manipulating such a name of a variable that is present locally in the function as well as in the namespace that is being accessed, the compiler will require more precision from you. You will need to specify what name is being called.

Combination of Namespaces

Introduction

Various namespaces can be part of the same file and the same application. You can create each namespace and specify its own members in its delimiting curly brackets. With various namespaces on the same file or application, you can have the same variables in different namespaces. Here is an example of two namespaces: 

To access the member of a namespace, use the scope access operator appended to its name and call the desired member. Here is an example:

Using the scope access operator like that, you can perform any operation on any member of one namespace applied to a member of another namespace.

We saw earlier that the using namespace routine allows accessing the members of a namespace. After typing it, if the name of a variable appears under a using namespace, the compiler would need to reconcile or identify it; if the name of such a variable is not recognized as part of the namespace that is being accessed, the program would not compile. For example, here is an example that uses two using namespace routines:

The above program would not compile because the compiler does not understand what discount is being referred to in the second discount call: is it InterestAndDiscount::discount or BuyAndSell::discount?

If you want to use different namespaces with the using namespace routine, each namespace will have to control its scope. One solution would be to create a “physical” scope for each namespace. Here is an example: 

Before creating a “physical” scope, we saw that the compiler is able to point out what problem occurred at compilation time. Fortunately, the compiler is able to explicitly designate what problem it encountered. In this case there is a conflict in name resolution: two namespaces have a member of the same name.

The solution, which is commonly used, is to qualify the variable that is causing the conflict. You may want to qualify only the second discount call because the compiler will associate the first discount call with the first using namespace. The safest way is to qualify both calls to the discount variable, as follows:

Nesting Namespaces

Nesting a namespace is the ability to include a namespace inside (as part of the body) of another namespace. To do this, create the intended namespace as a member of the parent namespace. The nested namespace should have its own name and its own body. Here is an example:

To access a member of a nested namespace, first call its parent, type the :: operator, type the name of the nested namespace, followed by the :: operator, then type the name of the variable you are trying to access. Here is an example:

Following the same logic, you can have as many namespaces and as many nested namespaces in your application as you desire. If you nest a namespace, you can use as many "::" operators to qualify each member of the nested namespace as you want. Here is an example:

Otherwise, you can create a using namespace for each namespace and make sure that each one of them controls its scope. As long as you are using the scope access operator to identify the variable that is being accessed inside of a using namespace, you can call the member of any namespace in any scope, provided you qualify it.

The std Namespace

To avoid name conflicts of the various items used in its own implementation, the C++ Standard provides a namespace called std. The std namespace includes a series of libraries that you will routinely and regularly use in your programs.

The following libraries are part of the std namespace:

Therefore, whenever you need to use a library that is part of the std namespace, instead of typing a library with its file extension, as in iostream.h, simply type the name of the library as in iostream. Then, on the second line, type using namespace std;

As an example, instead of typing

#include <iostream.h>

You can type:

Because this second technique is conform with the C++ Standard, we will use it whenever we need one of its libraries.