Namespaces exist to simplify the task of giving names to classes and functions. In C, all structs and functions are in the global namespace (unless they are made static). This means that it is very possible that a clash may happen between methods or structs defined in different libraries.

The most common method used to solve this problem in C and earlier versions of C++ was creating prefixes. For example, if a group developed a library called YZ, they would prefix all symbols define by this library with the YZ_ prefix. Therefore, this would prevent a clash with other symbols defined in different libraries.

Modern languages avoid this problem by making all code part of a module, where definitions of symbols are maintained. Symbols can only be referenced by importing a module, according to the rules of the language. For example, Java has packages, C# has assemblies, and Python has modules.

In C++, namespaces are not required, but are strongly encouraged for new development. Using namespaces means that there are less opportunities for clashes with software that was written by other people.

Examples

Here is an example of how to define a namespace called “Example”:

namespace Example {
  class A {
   void test();
  }
}

Code can be added to a namespace by simply using the namespace block as show above:

namespace Example {
void A::test() { std::cout << " a test \n"; }
}

To use a class defined in a namespace, you can refer to the fully qualified name (namespace + class name):

void test2() {
   Example::A a = new Example::A();
}

The second possibility is employing the using clause:

using namespace Example;
void test3() {
   A a = new A();
}

An exception is thrown, as we have seen in the article about exceptions when the keyword throw is used. Then, a new object of the time determining the exception is created. For example, we can create a new exception in the following way:

void Obj::AMethod() {
   // ....
   if (error)
      throw new MyCustomException("something bad happened");
}

An exception is catch by a catch block that can be added to any code surrounding the place where the exception was thrown. Surrounding here means not only the code that directly throws the exception, but also any code that called the method where the exception is being thrown.

Here is an example:

void Obj::Example() {
   try {
   // ...
      this->AMethod();
   } catch (MyCustomException &e) {
      // process the exception here
   }
}

The main problem we are concerned about here is what happens between the moment the exception is thrown and the moment the program can restart on the catch block.

The main problem with catching exceptions, is that we need to make sure that no additional exceptions will be thrown during the process of destroying objects. For example, if the code above has an object with a destructor that throws another exception, then we have a problem.

Notice that, when throwing an exception, C++ maintains a context, which determines what destructor will be called in response to the exception. The fact is that all objects created in the context between the place where an exception was thrown until the catch block need to be destroyed.

If we send an exception during the destruction process, then C++ can become confused about what objects needs to be destroyed as a result. It is as if there were are double queue of objects that need to have their destructor called.

In such a situation, C++ won’t know what to do, and the program will simply stop working correctly and crash.

To avoid problems like this, the main suggestion is that we should avoid throwing exceptions on a destructor. We never know in what context a destructor will be called, so it is better to avoid throwing exception on any destructor.

An exception is represented in C++ by an object that encodes the condition that caused the exceptional event. One can use this object by means of the throw keyword.

The try/catch mechanism allows one to create a context in which we can protect against exceptions. For example

class MyException { /* ... */ }
int i = 0;
try {
  i = performCalculation();
}
catch (MyException &e) {
   cout << "an exception occurred\n";
}

Observations: * note that in the catch clause, the exception is taken by reference. This is useful to avoid the need of copying the object.

Once you detect an exceptional condition, the exception can be throw using code like this:

if (conditionHappened)
  throw new MyException();

It may come as a surprise to you that we, as programmers of high level applications, have direct access only to locations in the random access memory (RAM). Whenever it is necessary to have access to disks, the network servers, or other types of store memory, this is done in an indirect way, through manipulation of main memory.

A variable is a named memory, that can be used to read and write information. In this sense, variables are nothing more than “buckets” that can be used to store whatever values are needed for a specific computation. However, as different materials require different containers, we also have different types of variables for the various contents that can be stored in it.

Suppose, for example, that the value to be stored is an integer number. In C++ this is called an int, and there is a specific declaration for each variable of the integer type, so the computer knows that only integers will be stored in that location.

Types of variables

There are just a few basic variable types in C++. They can be either numeric (such as integers and floating point numbers) , characters (such as the letters of the alphabet), or Booleans (representing the values true or false). What makes C++ rich is the several ways in which these basic building blocks can be combined. For example, one can have sequences of variables, variables that can be negative (signed) or only non-negative (unsigned), or variables that have more or less space to store values (short or long). Moreover, C++ allows these basic variable types to be combined into complex data objects, as we will see later in this book.

The basic types are the following:

Integers: they are declared using the keyword int. They represent integer number that are positive or negative. The limit on the integer size is dictated by the architecture in which the compiler has been implemented. Many modern computers store integers in four bytes, thus 2^32 is a practical limit for the values that can be stored in an integer variable.

Floating point numbers: Floating point numbers are used to represent real numbers in an approximate way. Remember that real numbers may have an infinite representation (for example, Pi), therefore only approximations can be stored in a computer. C++, as its antecessor C, has two main types for floating point numbers: float and double. A double is supposed to have more storage capacity than floats, and this is usually the case depending on the computer used. Although both types are available, its considered better to used only doubles to avoid rounding problems.

Characters: a character, declared as a char, can be used to store any alphanumeric values, such as the letters from ‘a’ to ‘z’, numeric values from ’0′ to ’9′ when they are not interpreted as numbers, and other codes such as punctuation symbols, etc.

One of the big advantages of programming with objects is that they can behave differently based on who the messages are sent to. This kind of dynamic behavior is called polymorphism, and is implemented in C++ by the virtual function mechanism.

What is a virtual function?

A virtual function is a member of a class that can be overriden by a derived class to provide different functionality.

For example, a member function draw can be used to determine how a graphical object is drawn on the screen. Depending on the concrete type of the object, however, the shape of the object may change, and the way it is drawn will be different. The function draw in this case is a candidate to be implemented as a virtual function, which will have different implementations for each of the concrete classes.

Creating virtual functions in C++

A virtual function can be created in C++ with the use of the virtual keyword before the declaration of the member function. For example:

class Button {
  virtual void draw() {
    // drawing a generic button
  }
};

class RoundButton {
  virtual void draw() {
    // draw button with a different shape
  }
}

A public data member of member function is one that can be accessed by any user of the class, independent of where the user is located. Thus, member functions that are declared public can be accessed anywhere, and represent the public interface of a C++ class.

Public member variables are also allowed to be viewed anywhere in the program. However, allowing this to happen is usually not a good idea, since it would inibit future changes in the representation of the data stored in a class. Unless you really need to do this for some reason (for example, compatibility with C code), you should avoid the creation of public member variables in a C++ class.

Private member variables, on the other hand, are not visible outside the class where they are declared. This is the preferred way of declaring member variables in C++, since it guarantees that the usage of data is limited to the class itself.

Like private member variables, private member functions are also useful in C++ programs. Such member functions are used in the implementation of the class, and are not accessible to users of the class. Every member function that is not part of the interface should be made private (or at least protected).

In fact, C++ defines private access as the default level of access for class member. That is, if you don’t specify anything as the access level, then the member will be considered private.

The other level of accessibility is the protected level. A member function or member variable is protected if it is accessible only inside a class or by the classes that derive from it. Therefore, only classes that inherit from the class where the member is contained can have access to the function or variable.

Protected members of a class are useful to provide functionality for derived classes. However, they should be used with care. One of the main problems, is that classes that expose too many details to derived classes may have difficulties when changing their internal representation, since an unspecified number of derivate classes may be using the protected information.

Example

Here is an example of the access level described above. Note that the method Director::getInfo() incorrectly tries to access getAge, since it is a private method.

class Employee {
  // private member variable
  int age;
  // private member function
  int getAge() { return age; }
public:
  // public member variable (don't do this!)
  std::string name;
  std::string getName() { return name; }
protected:
  // these members are visible only inside Employee
  // and derived classes
  std::string telephone;
  std::string getTelephone() { return telephone; }

};

// A derived class
class Director : public Employee {
   public:
   void getInfo();
};

void Director::getInfo() {
   // this works - protected
   cout << getTelephone() << "\n";
   // this doesn't work - private to Employee
   cout << getAge() << "\n";
}

• Buy The C++ Programming Language: Special Edition (3rd Edition) at Amazon.

One of the necessary factors in creating good software is guaranteeing that it satisfy its requirements. One of the simplest methods for doing this is using the assert facility provided by the standard C++ library.

Using Assert

Assert is a mechanism that allows a program to stop an error in its tracks whenever it is detected.  Assert is implemented in C++ as a macro, where the first argument is a boolean expression. This expression is evaluated, and its result is always expected to be true.

For example, the following is a typical use of assert:

void test(int value) {
  assert(value > 0);
  // normal processing
} 

In the example above, the assert tests if the argument passed to function test is greater than zero. If this is true, processing continues as normal. However, in the case that value is negative or zero, the assertion fails and the program stops immediately.

The assert macro is defined in assert.h, a header file that is  also used by the C compiler — so you can use assert on C or C++.

Using assert in a testing environment is a first step towards guaranteeing that we have the correct values before our algorithm starts. It is an easy method and has been effectly used in this way by many experienced programmers. 

Disadvantages of Assert

Although there are many advantages on using assert, one also needs to be aware of the problems in its use. First, asserts are not a substitute to using exceptions. When there is a possibility of recovery from an error, then the exception mechanism should be used. This way, the programmer has control over how a failure in the code must be handled. With an assert, on the other hand, the whole program stops.

In general, asserts should not be used on production code. The reason is that asserts are not graceful, they just stablish that an error ocurred, and stop the program. This is certainly not the behavior required in production, where the appropriate steps need to be taken to guarantee that user data is preserved.

Conclusion

Asserts are a powerful mechanism provided by C++ to guarantee that certain conditions are present on a specific function. If the expression given as input is not true, then the assert will automatically call the attention of the developer.

Asserts should be used sparingly, however, and not at all in production. Thankfully, all implementations of assert have a mechanism to disable it in production code. Check the documentation of NDEBUG in your favorite compiler for the details.