Variables in C++

July 13th, 2009 by carlos


Programming is all about creating change in the way information is stored in a computer. To make this possible, we need easy access to the contents of computers memory. This is what programming language variables allow us to do: they give a simple way to store and retrieve information into the computer’s memory.

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.

When Should You Create A Virtual Function?

June 22nd, 2009 by carlos


One of the questions raised by people starting to use C++ and virtual functions is: when should I use virtual functions?

To answer this question, you need to understand the reason why virtual functions exist in the first place.

A virtual function is a mechanism used for polymorphism in the C++ language. The standard is example is the drawing method of a shape class.

 
class Shape { public virtual void draw(); } 
class Rectangle : public Shape {
  public virtual void draw();
}

What is happening here is that the draw method varies between Shape and Rectangle. Therefore, it doesn’t make sense to have only one implementation. You need to have one version of draw for each of the classes Shape and Rectangle.

Whenever you have a situation where classes in the same hierarchy need different implementations, then virtual is the keyword you need to use. With virtual we are free to redefine a member function on a derived class.

On the other hand, member functions that were not defined with the virtual keyword cannot be redefined by derived classes. The reason for that is that, since “virtual” is not used, the compiler doesn’t know about different versions of the member function on the derived classes. Therefore, the compiler will call the wrong version of the member function.

General Techniques

Programmers diverge on the general technique used to say if a method will be virtual or not. Some people believe that you should make all, or at least most of your methods virtual. The idea is that you never know what might be useful to override later, so it is better to leave the options open.

The other group of developers believe that it is better to define only a few member functions as virtual. The reason is that then you will have more control on what the derived classes can do.

The arguments on both sides are good, and as most things in programming, it comes to choosing a side and sticking to it.

Conclusion

Virtual functions are the main mechanism that allows different behavior for classes in the same hierarchy. In this way, we should be careful in defining what virtual functions are virtual and what are not. Understanding the virtual keyword you have better ways to defining correct behavior in your classes.

Virtual Functions in C++

April 26th, 2009 by carlos


Object oriented programming is a style of programming that requires that functionality be attached to objects, instead of freely available through functions. C++, although not being a pure object oriented language, supports the notion of objects and classes of objects.

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
  }
}