Home

C++ Classes

 

Introduction to Classes

A class is a technique of creating one or a group of objects to be considered as an entity. To create a class, you must type class or struct, followed by a name, followed by an opening curly bracket "{", a closing curly bracket "}", and a semi-colon. Here is an example:

struct house { };

One of the types of things you can include in a class is a function. To do this, you write the function exactly as we saw earlier. Here is an example:

struct house
{
	int protect()
	{
		return 0;
	}
};

int main()
{
	return 0;
}

When a function is created outside of any class, it is called a function. When a function is created inside of a class, it is called a method. For the rest of our lessons, we will use the word "method" to indicate that the function belongs to a class.

You can include or create as many methods as you judge necessary in the body of a class. After creating a class, in order to use it, you must first create an "object" from it. This means that you must "declare" the class. To do this, for example in the body of main(), type the name of the class followed by another name that represents the object. Here is an example:

struct house
{
	int protect()
	{
		return 0;
	}
};

int main()
{
	house home;

	return 0;
}

After this declaration, the word home is called an object. After creating the object, such as home above, to access one of its method, type the name of the object, followed by a period, followed by the name of the method, its parentheses, and a semi-colon. Here is an example:

struct house
{
	int protect()
	{
		return 0;
	}
};

int main()
{
	house home;

	home.protect();

	return 0;
}

You don't always have to primarily create an object before using a class. To apply this exception, the name of a method that belongs to a class must be preceded with static. Here is an example:

struct house
{
	static int protect()
	{
		return 0;
	}
};

int main()
{
	return 0;
}

When a method has been created with the static keyword, it is called a static method. To access it outside of the class, for example to access the above protect from main(), you can type the name of the class, followed by ::, followed by the name of the method, its parentheses, and a semi-colon. Here is an example:

struct house
{
	static int protect()
	{
		return 0;
	}
};

int main()
{
	house::protect();

	return 0;
}
   

 

Namespaces

 

Introduction

When creating your classes, one of the most important rules you must observe is that two classes in the same program must not have the same name. For example, the following program will not compile:

struct CHouse
{
	int protect()
	{
		return 0;
	}
};
struct CCar
{
	int drive()
	{
		return 0;
	}
};
struct CHouse
{
	int showroof()
	{
		return 0;
	}
};

int main()
{
	return 0;
}

Notice that there are two classes named house in this program. If you have different people working on the same project, it would not be unusual to have two classes with the same name. The consequence is that, if these classes are used in the same program, the program would not compile.

A namespace is a technique of grouping some functions and/or classes to create an entity. This has the main goal of eliminating the probability of having two classes of the same name. For example, if different people work on the same project, each one can create his or her own classes but put them in only his or her namespace. This way, even if they happen to have a class each with the same name, there is no risk of having a name conflict.

To create a namespace, type namespace followed by a name. Like a class, a namespace must have a body delimited by an opening curly bracket "{" and ending with a closing curly bracket "}". Here is an example:

namespace family
{

}

For the rest of our lessons, we will start the name of a namespace with an uppercase letter.

In the body of the namespace, you can create the classes (and/or functions) as you want. Here is an example:

namespace Family
{
	struct CHouse
	{
		int protect()
		{
			return 0;
		}
	};
	struct CCar
	{
		int drive()
		{
			return 0;
		}
	};
}

Remember that the struct or class keyword of a class can be preceded with private or public to control its "visibility" outside of its assembly. Therefore, the above classes can be preceded with the public keyword as follows:

namespace Family
{
	public struct CHouse
	{
		int protect()
		{
			return 0;
		}
	};
	public struct CCar
	{
		int drive()
		{
			return 0;
		}
	};
}

In the same way, you can have as many namespaces as you want. Each namespace can have any valid content. Inside of a namespace, two classes must not have the same name. Inside of a program, two namespaces must not have the same name. Consider this:

namespace Family
{
	public struct CHouse
	{
		int protect()
		{
			return 0;
		}
	};
	public struct CCar
	{
		int drive()
		{
			return 0;
		}
	};
}

int main()
{
	return 0;
}

As done previously, you can create static methods as members of your classes. This is also valid even if a class is part of a namespace. Here is an example:

namespace Family
{
	public struct CHouse
	{
		static int protect()
		{
			return 0;
		}
	};
	public struct CCar
	{
		int drive()
		{
			return 0;
		}
	};
}

int main()
{
	return 0;
}

Before accessing a non-static method of a class, you must first create an object from it. Before the type of declaration we saw earlier, you must precede it with the name of the namespace followed by ::. Here is an example:

namespace City
{
	public struct CHouse
	{
		int showroof()
		{
			return 0;
		}
	};
}

int main()
{
	City::CHouse town;
	
	town.showroof();

	return 0;
}

As mentioned earlier, if a method is static, you don't have to create an object from it before using it. You can access it directly by typing the name of the namespace followed by ::, followed by the name of the class. Here is an example:

namespace Family
{
	public struct CHouse
	{
		static int protect()
		{
			return 0;
		}
	};
	public struct CCar
	{
		int drive()
		{
			return 0;
		}
	};
}

int main()
{
	Family::CHouse::protect();

	return 0;
}
 

using a Namespace

We saw that, to call an object or a method that is part of a namespace, you must "qualify" that method or object using the period operator. Instead of using this approach, if you already know the name of a namespace that exists or has been created in another file, you can use a special keyword to indicate that you are using a namespace that is defined somewhere. This is done with the using keyword. To do this, before accessing the namespace, type using followed by the name of the namespace. Here is an example:

namespace Family
{
	public struct CHouse
	{
		static int protect()
		{
			return 0;
		}
	};

	public struct CCar
	{
		int drive()
		{
			return 0;
		}
	};
}

int main()
{
	using namespace Family;
	
	Family::CHouse::protect();

	return 0;
}

With the using keyword, you can omit the name of the namespace when accessing a class that belongs to the namespace. Here is an example:

int main()
{
	using namespace Family;
	
	CHouse::protect();

	return 0;
}

Using Various Namespaces

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:

namespace Family
{
	public struct CHouse
	{
		static int protect()
		{
			return 0;
		}
	};
	public struct CCar
	{
		int drive()
		{
			return 0;
		}
	};
}
namespace City
{
	public struct CHouse
	{
		int showroof()
		{
			return 0;
		}
	}
}

To access the member of a namespace, use the :: operator appended to its name and call the desired member. Using the :: operator, 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 namespaces:

namespace Family
{
	public struct CHouse
	{
		static int protect()
		{
			return 0;
		}
	};

	public struct CCar
	{
		int drive()
		{
			return 0;
		}
	};
}
namespace City
{
	public struct CHouse
	{
		static int showroof()
		{
			return 0;
		}
	};
}

int main()
{
	using namespace City;
	using namespace Family;
	
	CHouse::protect();

	return 0;
}

The above program would not compile because the compiler does not understand what house is being referred to in house::protect(): is it the house class of the Family namespace or the house of the City namespace? You would then receive an ambiguous symbol error:

.\Exercise.cpp(35) : error C2872: 'house' : ambiguous symbol
        could be '.\Exercise.cpp(4) : Family::house'
        or '.\Exercise.cpp(22) : City::house'

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:

namespace Family
{
	public struct CHouse
	{
		static int protect()
		{
			return 0;
		}
	};

	public struct CCar
	{
		int drive()
		{
			return 0;
		}
	};
}
namespace City
{
	public struct CHouse
	{
		static int showroof()
		{
			return 0;
		}
	};
}

int main()
{
	{
		using namespace Family;
		CHouse::protect();
	}

	using namespace City;
	CHouse::showroof();

	return 0;
}

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 can qualify only the second house call because the compiler will associate the first house call with the first using namespace. The safest way is to qualify both calls of the member, as follows:

namespace Family
{
	public struct CHouse
	{
		static int protect()
		{
			return 0;
		}
	};

	public struct CCar
	{
		int drive()
		{
			return 0;
		}
	};
}
namespace City
{
	public struct CHouse
	{
		static int showroof()
		{
			return 0;
		}
	};
}

int main()
{
	using namespace Family;
	using namespace City;

	Family::CHouse::protect();
	City::CHouse::showroof();

	return 0;
}

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:

namespace Country
{
	namespace City
	{
		public struct CHouse
		{
			static int showroof()
			{
				return 0;
			}
		};
	}

	struct CCar
	{
	};
}

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:

namespace Country
{
	namespace City
	{
		public struct CHouse
		{
			static int showroof()
			{
				return 0;
			}
		};
	}

	struct car
	{
	};
}

int main()
{
	Country::City::CHouse::showroof();

	return 0;
}

Following the same logic, you can have as many namespaces and 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 you want.

You can also use the using namespace routine by qualifying each member inside the using namespace that “needs” its parent:

namespace Country
{
	namespace City
	{
		public struct CHouse
		{
			static int showroof()
			{
				return 0;
			}
		};
	}

	public struct car
	{
	};
}

int main()
{
	using namespace Country::City;

	CHouse::showroof();

	return 0;
}

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 :: operator to identify the member that is being accessed inside of a using namespace, you can call the member of any namespace in any scope, provided you qualify it.

Built-In Namespaces

 

The System Namespace

The Microsoft .NET Framework contains a namespace named System. This is the primary namespace of the classes used to create applications. This namespace contains a class named Console. This class represents the DOS window that is used to display the results of a console application:

The Console class contains methods used to display information on the screen or to retrieve information from the user who types it in the DOS window. The method that is used to display text on the screen is called Write. To use the Write() method, inside of the parentheses, type the sentence between double-quotes. Here is an example:

int main()
{
	System::Console::Write("Welcome to C++/CLI Programming");

	return 0;
}

This would produce:

Besides the Write() method, the Console class also provides a method called WriteLine(). The difference is that, after displaying something on the screen, the Write() method keeps the caret on the same line but WriteLine() transfers the caret the next line.

The std Namespace

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:

algorithm iomanip list ostream streambuf
bitset ios locale queue string
complex iosfwd map set typeinfo
deque iostream memory sstream utility
exception istream new stack valarray
fstream iterator numeric stdexcept vector
functional limits

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, you can just 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:

#include <iostream>
using namespace std;

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

Like the System namespace, the std namespace provides its own means of displaying a value to the screen. In the std namespace, the class that takes care of this is called cout. To use it, type cout, followed by <<, followed by the value, and end it with a semi-colon. Here is an example:

#include <iostream>
using namespace std;

int main()
{
	cout << "Welcome to C++/CLI Programming";

	return 0;
}

As mentioned previously, you can use different namespaces in the same program. Based on this, you can use both the std and the System namespaces in your program. The compiler would know exactly where each is located. To access a class that is part of a certain namespace, you can call the namespace followed by the :: operator and access the class. Here are examples:

#include <iostream>

int main()
{
	std::cout << "Welcome to C++/CLI Programming. ";
	System::Console::WriteLine("C++/CLI is the new full-featured C++");

	return 0;
}

You can also type using namespace for each namespace that you will need in your program. The above program could be written as:

#include <iostream>
using namespace std;
using namespace System;

int main()
{
	std::cout << "Welcome to C++/CLI Programming. ";
	System::Console::WriteLine("C++/CLI is the new full-featured C++");

	return 0;
}

Remember that, when calling using namespace, you can omit qualifying a class by preceding it with the namespace:

#include <iostream>
using namespace std;
using namespace System;

int main()
{
	cout << "Welcome to C++/CLI Programming. ";
	Console::WriteLine("C++/CLI is the new full-featured C++");

	return 0;
}

C Routines

The C computer language is the parent of C++ and C++ is the parent of the C++/CLI language. To maintain backward compatibility, the operations performed in C were made available to C++ and most standards of C++ are available in C++/CLI. Based on this, you can transparently include C routines in your C++/CLI program.

The libraries of the C language available in C++ are:

cassert cios646 csetjmp cstdio ctime cctype
climits csignal cstdlib cwchar cerrno clocale
cstdarg cstring cwctype cfloat cmath cstddef

Like C++/CLI and C++, the C computer language has its own mechanisms to display a value on the screen. One of the functions used to do this is printf_s. To use it, add an opening and a closing parentheses to it. Inside of the parentheses, enter the value you want to display. Here is an example:

#include <iostream>
using namespace std;
using namespace System;

int main()
{
	cout << "Welcome to C++/CLI Programming. ";
	Console::WriteLine("C++/CLI is the new full-featured C++");
	printf_s("C++/CLI highlights the best of C++ and significantly modernizes it");

	return 0;
}

Of course, there are many other details and aspects concerning these built-in namespaces, libraries, and operations. We will review as many as possible in future lessons.

 

Previous Copyright © 2006-2009 FunctionX, Inc. Home