Data Type Redefinitions

Introduction

The Type Definition

In the previous lessons, we used some of C++ keywords to identify the data types. Examples were int, short, double, unsigned int, or char. The C++ language allows you to create a new name for a data type without changing the meaning of that data type. This allows you to name a data type with a name that is easier for you. This technique doesn't change anything about the data type, it only gives it a new name you can use in your program.

To re-define the name of an existing data type, you use the typedef keyword. The formula to follow is:

typedef KnownDataType NewName;

The typedef keyword is required to let the compiler know that you are redefining an existing data type. The DataType is any of those we have learned so far. It could be an int, an unsigned int, a char, a double, etc. While a data type can be made of one word (such as short) or more than one word (such as unsigned int), the new name you are creating for the data type must be in one word.

An example of renaming a data type is:

typedef int NumberOfStudents;

In this case, NumberOfStudents is just a new name for an int. It can be used as a new data type exactly as if you were using an int. Here is an example that redefines an int data type and uses it in a program:

Here are examples of creating new names of existing data types using typedef:

typedef unsigned int UINT;

typedef unsigned char UCHAR;

typedef unsigned long ULONG;

typedef long double LONGDOUBLE;

Constant Values

Introduction

A constant is a value that does not change. There are various categories of constants you will be using in your programs. For example, the algebraic numbers you are aware of are constants because they never change. Examples of constant numbers are 12, 0, 1505, or 88146. Therefore, any number you can think of is a constant.

Every letter of the alphabet is a constant and is always the same. Examples of constant letters are d, n, c.

Some characters on your keyboard represent symbols that are neither letters nor digits. These are constants too. Examples are #, &, |, !.

Some values would be constant by default, but their constancy sometimes depends on the programmer. For example, one programmer can define a constant PI as 3.14. Another programmer can decide that the constant PI would be 3.14159. Therefore, you will be defining your own constant values as you see fit for the goal you are trying to achieve.

There are two main techniques you use a constant value in C++. To simply display it using the cout << extractor, you can type its value on the right side of the << symbols. You can also define it first using an appropriate name, and then using that name to display the constant. Here are two examples

To create your own constant value, you can give it a name. This allows you to manage it from one standpoint. Imagine you want to use 3.14 in various sections of the program. If you decide to change the number from 3.14 to 3.14159 or another value, you would have to find every mention of 3.14; this can lead to a programming error. The alternative is to declare a variable and assign it the desired value. The new and defined value is called a constant.

Macro Definition of a Constant

There are two main techniques used to create constant values. The old way, which was used with the C language, widely used in documentation and help files consists of using the define keyword. The syntax of creating a constant using the define keyword is:

#define ConstantName ConstantValue

The # symbol and the define keyword are required; they inform the compiler that the following name represents a constant. The ConstantName represents a valid name for the desired constant. The name follows the same rules we learned for defining names in C++. The ConstantValue can be a character, an integer, a floating-point value, or an expression. If the constant value is an integer or a floating-point value, you can type it. If the value is a character, include it between single-quotes. If the value is a word or a sentence, include it in double-quotes. Because #define is referred to as a macro, the definition doesn't end with a semi-colon. Here are examples:

#define AGE 12 // AGE represents the constant integer 12

#define ANSWER ‘y’

#define MAXSTUDENTS 35

#define PI 3.14159 // PI represents 3.14159

After defining the macro, the last value can be used in a program as a constant. For example, you can display it using cout. Here is an example:

#include <iostream>

using namespace std;



#define EmploymentStatus "Full Time"



int main()

{

	cout << "Status: " << EmploymentStatus << endl;



	return 0;

}

This would produce:

Status: Full Time

User-Defined Constants

Another technique of creating a constant consists of using the const keyword. The formula used with the const keyword is:

const ConstantName = ConstantValue;

Or

const DataType ConstantName = Value;

The const keyword is required to inform the compiler that you are creating a constant.

The ConstantName specifies the name of the constant value; it follows the rules we have applied for the names of variables.

The DataType, although optional, is used to let the compiler know the kind of value the constant is. If you don't specify a data type, the compiler would assume that the constant is an integer. Therefore, make it a habit to always specify the data type when creating a constant using the const keyword. The data type can be any of those we have used so far.

Use the assignment operator to assign the desired constant to the name.

Examples of creating constants with the const keyword are:

const float PI = 3.14159;

const unsigned int MaxStudents = 42;

const string Country = “New Zealand”;

const double Distance = 1678212;

After creating the constant, you can use its name in the program to access its value. As we will learn in the next lesson, you can involve it in an operation. You can also display its value using cout. Here is an example:

#include <iostream>

using namespace std;





int main()

{

	const double PI = 3.14159;



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



	return 0;

}

This would produce:

PI = 3.14159

Built-In Constants

To assist you with constants, the C++ language ships with many of them so you can use them directly in you code. Those constants have names they can be recognized with. For example, the minimum value of the short integer is called SHRT_MIN. In the same way, the maximum short integer is identified by SHRT_MAX. You can use either of these constants as follows:

This would produce:

The minimum signed character: -128

The maximum signed character: 127

The minimum short integer is: -32768

The maximum short integer is: 32767

According to the C++ Standard, the integral constants are defined in the climits library but they can be defined as one compiler chooses to. For example, in Borland C++ Builder, they are in the _lim.h library. In the KDevelop and Microsoft C++ compilers they are in the limits.h file.

The integer constants defined in the climits library are:

In the same way, C++ provides constant double-precision numbers in the cfloat library. These constants are:

The C++ Standard also defines a constant as NULL. This constant is used to designate that a pointer does not hold a valid value. The NULL constant is defined in the cstddef library.