Chapter 4

C++ Declarations

4.1  INTRODUCTION

To write a C++program, it is necessary to know the syntaxes of the language. This enables a programmer to write error-free programs. If the programmer is not aware of the basic rules of the language, he/she may fail to write program, even though the logic is clear.

A few basic concepts of C++ language, such as syntaxes, data types, and keywords, are discussed in this chapter to help the programmer to develop programs. As the object-oriented programming is a new technology, the programmer will find a notable amount of new concepts to learn and master in it.

Most of the C++ programs in this chapter are implemented with former C language. Few rules and regulations of C programs are valid in C++ too. Intact the C++ is upward compatible to C. Hence the programs with C can be executed with C++. C++ allows us to use variable declaration anywhere in the program, and new operators such as reference and scope access operator are introduced. All these concepts are illustrated with figures and examples.

4.2  TOKENS

The smallest individual unit in a program is known as ‘token’. C++ programs contain various components. The compiler identifies them as tokens. Tokens are classified into the following types and are also indicated in Figure 4.1.

Fig. 4.1 Types of tokens

1. Keywords – Reserved by the compiler.
2. Identifiers – Names of variables, arrays, classes, functions, etc. are identifiers.
3. Constants – Constants are fixed values.
4. Operators – Operators are different types and are used in expressions.
5. String – Sequence of characters.

The keywords are reserved set of words with fixed meanings. The variables are used to hold data temporarily. The operators are used to perform different operations such as arithmetic and logical. Values such as 1, 5, 2.5, etc. are known as constants. The operators such as #, ?, and ~ are known as special characters. The # is used for preprocessor directive; ? is a conditional operator; and ~ is used for bitwise operation. The detailed descriptions of these tokens are described in following sections.

4.2.1   Keywords

The ‘C++’ keywords are reserved words by the compiler and are assigned fixed meanings. All ‘C’ keywords are valid in C++. The programmer may not apply them in the programs for defining variable names; however, few ‘C++’ compilers permit to declare variable names that exactly match with the keywords.

The common keywords between C and C++ are listed in Table 4.1 and the additional keywords of C++ are listed in Table 4.2. These keywords are used with classes, templates, and exception handling, etc. Table 4.3 contains keywords added by ANSI committee. Table 4.4 contains additional keywords provided by Turbo C++ compiler.

 

Table 4.1 C and C++ Common Keywords

Table 4.2 Additional C++ Keywords

asm catch class delete friend inline new operator

private      protected      public      template      this      throw      try      virtual

Table 4.3 Keywords Added by ANSI Committee

Table 4.4 Additional Keywords in Turbo C++

4.2.2   Identifiers

Each variable is represented by a symbol using identifiers. Identifiers are names of variables, functions, arrays, etc. In other words, identifiers refer to variety of entities such as structures, unions, enumeration, constants, typedef names, functions, and objects (refer Figure 4.2).

Fig. 4.2 Types of tokens

C++ identifier always starts with an alphabet and it is a plain sequence of alphabets and/or digits. C identifier does not allow blank spaces, punctuation, signs, etc.

Identifiers are user-defined names and are generally defined in lower case letters. However, the upper case letters are also permitted. The underscore (_) symbol can be used as an identifier. In general, underscore is used to link two words for the long identifiers. Valid identifiers are as follows:

length, area, volume, sUM, Average, etc.

Invalid identifiers are as follows:

Length of line, S+um, year’s, etc.

Rules for defining identifiers are as follows:

1. The identifier name must begin with a character or underscore and should not start with digit. No spaces are allowed between the characters in the variable but underscore is allowed.
2. The identifier name should not be a ‘C++’ keyword.
3. The identifier name can be a combination of upper and lower characters. For example, the variables suM, sum, and SuM are not same.

4.2.3   Constants

The constants in ‘C++’ are applicable to the values that do not change during execution of a program. There are several types of constants in ‘C++’. They are classified into the following groups as shown in Figure 4.3 and Table 4.5.

Fig. 4.3 ‘C++’ constants

Table 4.5 Constant Types

Example	Constant Type
542	Integer constant
35.254	Floating point constant
0x54	Hexadecimal integer constant
0171	Octal integer constant
‘C’	Character constant
“cpp”	String constant

Numerical Constants

Integer Constants:

Integer constants are represented with whole numbers. It requires minimum two bytes and maximum four bytes of memory.

The following concepts are essential for the numerical constants:

• The numerical constants are represented with numerical numbers. At least one digit is needed for representing the numerical number.
• The decimal point or fractional part or any other symbols are not permitted. Neither even blank spaces nor commas are permitted.
• Integer constant could be either positive or negative or may be zero.
• The number without a sign is assumed to be positive.

  Valid Examples: 10, 20, +30, −15, etc.

  Invalid integer constants: 2.3, .235, $76, 3*^6, etc.

Integers can be represented in octal or hexadecimal based on the requirement, besides decimals.

Octal has base 8 and hexadecimal 16. The octal numbers are 0, 1, 2, 3, 4, 5, 6, 7, and hexadecimal numbers are 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.

The representation of octal numbers in C++ would be done with leading digit 0 and for hexadecimal with leading 0X.

Following are few examples of octal and hexadecimal numbers:

027, 037, 072 – octal numbers

0X9, 0Xab, 0X4 – hexadecimal

Various constants are given in Table 4.5.

Real Constants:

Real constants are often known as floating point constants and can be represented in exponential or fractional form. Integer constants are unfit to represent many quantities. Many parameters or quantities are defined not only in integers but also in real numbers. For example, length, height, prize, distance are also measured in real numbers.

The following concepts are essential for real numbers.

• Decimal point is permitted.
• Neither blank spaces nor commas are permitted.
• Real numbers could be either positive or negative.
• Number without a sign is assumed to be positive.

  Examples of real numbers are as follows:

  2.5, 5.521, 3.14.

  The real constants can be written in exponential notation, which contains fractional and exponential parts. For example, the value 2456.123 can be written as 2.4561 X e^+3.

  The part that precedes ‘e’ is called as mantissa and following it is an exponent.

  In this example 2.4561 is mantissa and +3 is exponent.

  Following points must be noted while constructing a real number in exponential form:

• The real number contains mantissa and exponent.
• The letter ‘e’ separates the mantissa and exponent and it can be written either in upper or in lower case.
• The mantissa is either a real number represented either as decimal or as an integer.
• The mantissa may be either positive or negative.
• The exponent is an integer which may be either positive or negative.

Valid examples are 5.2e2, -2, 5.0e-5, 0.5e-3, etc.

Also in double type, the real numbers can be expressed with mantissa and exponent parts.

Character Constants

Single-character constants:

A character constant in C is represented with a single character and it is enclosed within single quotes. Each character constant has a particular integer value associated it.

Each character is represented with different ASCII value (the values are listed in Appendix 1). A character can also be represented with single digit or single special symbol or white space, all enclosed within a pair of single quote marks.

Example: ‘a’, ‘8’, ‘ ’, ‘&’, etc.

String constant:

String constants are sequence of characters enclosed within double quote marks. The string may be combination of all types of symbols.

Example: “Hello”, “India”, ”444”, “a”.

In short, the various constants are shown in Table 4.5.

A programming example for various constants is as follows:

 

Explanation:  In this programming example, various constants are assigned to different variables.

Symbolic Constants

A symbolic constant is defined in the same way as a variable. However, once the constant is initialized, the assigned value cannot be altered.

The constant can be defined in three ways: #define, const keyword, enum keyword

#define preprocessor directive: The #define preprocessor directive can be used for defining constant. The symbols defined using #define are called macros. The syntax of #define is as follows.

#define name constant_value

Explanation: #define price 152

In the above example, price symbolic constant contains 152 and data type, such as int, float, or char, is not mentioned. Every time when the preprocessor finds the word price, it substitutes with 152.

 

Explanation: In the above program, the value of pi is replaced by 3.14 during program execution. In the program instead of writing the value of pi as 3.14 we define directly the value pi as 3.14. The term pi is used for calculating the area and circumference of the circle.

Constant using const keyword:

Example:

const int price=152;

The above declaration defines a constant of type int. Here, data type is strictly maintained while execution and the value of constant cannot be changed during run-time.

 

Explanation: A constant value is assigned to the variable x and the same is displayed. If attempts are made to modify constant value, compiler shows an error (cannot modify the constant).

Constant Pointers

C++ allows us to create both constant pointer and pointer to constant. Consider the following example.

 

(1) Constant pointer: It is not possible to modify the address of the constant pointer.

Example:

char * const str=“Constant”;

In the above example, it is not possible to modify the address of the pointer str. Thus, the following operations will generate error.

// str=“san”; // cannot modify a constant object

// ++str; // cannot modify a constant object

(2) Pointer to constant: If pointer is declared to constant, only the value can be changed using actual variable which is not possible using pointer.

Example:

int const * pm=&k;

In the above example, pm is declared as pointer to constant. The following examples are possible and invalid operations.

// k=5;    // possible

// *pm=5   // cannot modify the constant object

// pm++;   // possible

// ++ *pm; // cannot modify a constant object

// *pm=5;  // cannot modify a constant object

(3) Pointer and variable both constants:

Example:

const char * const p=“ABC”;

In the above example, both the pointer and variable are constants. Hence, it is not possible to change the value and address of the pointer.

(4) Constants can be defined using enum as follows:

Example:

enum {a,b,c};

where a,b, and c are declared as integer constants with values 0, 1, and 2, respectively.

We can also assign new values to a, b, and c.

enum [a=5,b=10,c=15};

where a, b, and c are declared as integer constants with values 5,10, and 15, respectively.

4.2.4   Operators

C++ supports all the operators of ‘C’. In addition, C++ introduces few more operators. The new operators are <<, >>, ::, ::*, ->*,.*, delete, new, etc.

These operators are discussed in detail at the end of this chapter.

4.2.5   String Constants

String is represented by an array of characters. String constants are enclosed in double quotes. Following are the valid examples of string constants.

“Pearson”, “Delhi”, “India”, Singapore”, “Popular”, “publisher”, etc.

4.3  VARIABLE DECLARATION AND INITIALIZATION

4.3.1   Variable

A variable is used to store values. Each variable is stored in memory location(s). It can be of any data type such as integer, char, float, etc. A variable holds a single value at a time of its type; that is, values of variable vary, and the programmer can change the value of the variable.

4.3.2   Variable Declaration

The variable must be declared before they are used in the program. Once declared (1) the compiler obtains the variable name and (2) the compiler is notified about the data type of the variable being declared and helps in allocation of the memory. The variable can also be declared before main() and such variables are called external variables.

In C, all the variables must be declared in the declaration part. Hence, each time when one needs to declare a variable the programmer should go back to the beginning of the program.

C++ permits declaration of variables anywhere in the program. This makes the programmer more comfortable to declare the variables and need not go back to the beginning of the program. The declaration of variable consists of name of data type and variable list as follows.

The syntax of declaring a variable is as follows:

Data_type variable_name;

Example:

int age;

char m;

float s;

double k;

int a,b,c;

The int, char, float, and double are keywords to represent data types. Commas are used as separators for multiple variables.

4.3.3   Initialization

When a variable is declared, appropriate number of bytes is reserved for that particular variable in the random access memory. Bytes are filled with garbage values if the user does not assign them a value. If the user performs operations without initializing the variable, the result will be unexpected. Hence, before using a variable it is essential to initialize it. Assigning a value to the variable is called as initialization. When a value is assigned to the variable, the garbage value is removed and replaced with the given value.

Example:

int x;

Here, the integer variable x is declared and not initialized. When the variables are not initialized, neither they are set to zero by the compiler nor they remain empty. The variables contain garbage values. The user cannot predict the garbage value, which is system dependent. The garbage values differ for each system.

If you try to print the value of x in C, the statement printf(“%d”,x) will display the garbage value (-29281 on my system). The cout<<x in C++ will display the value 0. If you use both these statements one after another, the value displayed will be 0.

 

Explanation: In the above program, the first cout statement displays the value of x zero; the second statement displays the value of x as 5; and the third statement displays the value 6. In the third statement x is incremented first and then added to 5. This program is compiled under compact memory model. If the program is compiled and executed under any other memory model the resultant value will be garbage.

All the operations performed in the above program are directly put in the cout statement. If the above program is executed with the printf() statement, the program will display the garbage values.

The following program displays garbage value of the variables:

 

Explanation: In the above program, 5 is added to variable x and assigned to y. One may expect that the value of y to be 6. Here, the value of y is displayed as a garbage value. From the above program it is clear that if the variable is not initialized, it will be assigned to a garbage value.

In the afore-mentioned program, the statement y=5+(++x); it uses variables x and y. The variables x and y are not initialized. The variable y has no effect on the operation because it is at the left-hand side and the result of the expression is assigned on the right-hand side. The variable x holds a garbage value. Integer 5 is added to the garbage value of x and stored in the variable y. Hence the value of y displayed is 1134.

Initialization of variable can be done at the place where it is declared or anywhere in the program before their use. Variables declared can be assigned or initialized using assignment operator ‘=’. The declaration and initialization can also be done in the same line.

Syntax: variable_name = constant;

or

data_type varaible_name= constant;

Example:

x=2; where x is an integer variable.

Example:

int y=2;

Figure 4.4 shows an example of initialization of a variable.

Syntax:

data-type variable_name = value;

Example:

int k = 5;

In the above example, variable k of integer type is declared. The value 5 is stored in it.

int a,b,c,d;

a=b=c=d=5;

Fig. 4.4 Initialization of variable

In the above example all the variables a, b, c, and d are initialized to 5. An example is illustrated as follows:

 

Explanation: In the above program, variables, a, b, c, and d are declared. In next statement, all four variables are initialized with a value 5. First the value 5 assigned to variable d, then the value of d is assigned to c, c is assigned to b, and finally b is assigned to a.

Fig. 4.5 Initialization of variables

Here the variables are local and they are stored in the stack. Stack is the portion of the random access memory (RAM). Generally it is located at end of RAM to avoid overlapping of program and data memory. Figure 4.5 simulates this assignment.

4.3.4   Dynamic Initialization

The declaration and initialization of variable in a single statement at any place in the program is called as dynamic initialization. The dynamic initialization is always accomplished at run-time. Runtime means execution of program. Dynamic refers to a process carried out at run-time, for example dynamic initialization, dynamic memory allocation etc. The C++ compiler allows declaration and initialization of a variable at any point in the program. In C, initialization of variable can be done at any point but the variable must be declared at the beginning of the program illustrated as follows:

 

Explanation: The above program is executed with C compiler. The variables area and r are declared at the beginning because declaration in C is compulsorily done at the beginning. The multiplication of 3.14 and the variable r is assigned to the variable area. This assignment is done within the program. Thus, from the above program it is demonstrated that in C variable declaration is done at the beginning and initialization can be done at any point in the program.

 

Explanation: In the above program, the variables r and area are declared within the program. The declaration and initialization of a variable area is done in the single statement within the program. Consider the following statement.

float area=3.14*r*r;

In the above statement, float variable area is declared and product of 3.14*r*r is assigned to the variable area. The assignment is carried out at run-time. Such type of declaration and initialization of a variable is called as dynamic initialization.

 

Explanation: In the above program, the variables num and num1 are declared within the program and not at the beginning of the program. Once declared, they are used with cin statement that reads two integers and stores them in the variables num and num1. The cout statement displays entered values on the screen.

 

Explanation: In the above program, variable z is initialized with 102. The ASCII value of 102 is f; hence, the output is f.

 

Explanation: In the above program, the cin statement reads the string through the keyboard. The strlen() function is used to determine the length of the given string. The strlen() function calculates the length of the string and returns the length to variable len. The variable len is declared and value returned by strlen() is assigned to variable len. To avoid separate statements for declarations and initializations, both statements are combined as one statement. Declaration and initialization are carried out in one statement int len=strlen (name).

4.4  DATA TYPES IN C++

Data are collections of characters, digits, symbols, etc. The data are used to represent information. The data are classified into various types. Figure 4.6 indicates all data types. C++ data types can be classified as basic data type, derived data type and user-defined data type.

Fig. 4.6 C++ data types

4.4.1   Basic Data Type

The basic data types supported by C++ are described with their size in bytes and ranges in Table 4.6. Sizes of data types supported by C++ are shown in Figure 4.7.

 

Table 4.6 C++ Basic Data Types with Size and Range

Data Type	Size in Bytes	Range
char	1	−128 to 127
unsigned char	1	0 to 255
signed char	1	−128 to 127
int	2	−32768 to 32767
unsigned int	2	0 to 65535
signed int	2	−32768 to 32767
short int	2	−32768 to 32767
unsigned short int	2	0 to 65535
signed short int	2	−32768 to 32767
long int	4	−2147483648 to 2147483647
signed long int	4	−2147483648 to 2147483647
unsigned long int	4	0 to 4294967295
float	4	3.4e-38 to 3.4e+38
double	8	1.7e-308 to 1.7e+308
long double	10	3.4e-4932 to 1.1e+4932
enum	2	−32768 to 32767
bool	1	true/false

Fig. 4.7 Data types and their sizes

Type Modifiers

The keywords signed, unsigned, short, and long are type modifiers. A type modifier changes the meaning of the base data type to produce a new data type. Each of these type modifiers is applicable to the base type int. The modifiers signed and unsigned are also applicable to the base type char. In addition, long can be applied to double data type. When the base type is absent from a declaration, int is supposed.

 

The void Data Type

The type void is empty data type. It can be used in three ways:

• When specified as a function return type, void means that the function does not return a value.

  void message (char *name)

  {

  cout<<“Hello.”<< name;

  }

  Here, message() is a void function. The keyword void is preceded by the function name. This function when executed displays only message and does not return any value to the calling function.

• The void keyword also uses as argument for function. When found in a function heading, void means the function does not take any arguments.

  int fun(void)

  {

  return 1;

  }

  Here, the function is fun() and does not require any argument. It returns an integer value.

• When specified as a function return type and in function heading, that is, the function neither returns a value nor requires any argument.

  void fun (void);

  The above function neither returns a value nor requires any argument.

4.4.2   Derived Data Type

The derived data types are pointers, functions, arrays, and references.

Pointers

A pointer is a memory variable that stores a memory address. Pointer can have any name that is legal for other variable and it is declared in the same fashion like other variable but it is always denoted by ‘*’ operator.

int *x;

float *f;

char *y;

In the first statement ‘x’ is an integer pointer and it tells the compiler that it holds the address of any integer variable. In the same way ‘f’ is a float pointer that stores the address of any float variable and ‘y’ is a character pointer that stores the address of any character variable.

 

Explanation: In this program, x is an integer variable and *p is an integer pointer. The first cout statement displays the address of variable x. The address of x is assigned to pointer p. The pointer variables are always used to store address of another variable. The second statement displays the value of x using pointer p. Figure 4.8 explains pointers.

Fig. 4.8 Pointers

Functions

A function is a self-contained block or a sub-program of one or more statements that perform a special task when called. The C++ functions are more civilized than C. It is possible to use the same name with multiple definitions known as function overloading. Figure 4.9 illustrates the functions.

Fig. 4.9 Functions

A simple program on function is described as follows:

 

Explanation: In the above program, the function show() is defined. The function body contains only one cout statement. When the function is executed, a message is displayed. Functions are discussed in detail in Chapter 7 (Functions in C++).

Arrays

Array is a collection of elements of similar data type in which each element is located in separate memory location, for example

int b[4];

The above statement declares an array b[] which can hold four integer values. The following program illustrates use of array.

 

Explanation: In the above program, an array b [4] is declared and initialized. The cout statement displays the array elements. b[0] refers to first element, b[1] refers to second element, and so on. Figure 4.10 describes the elements in an array and their memory locations.

Fig. 4.10 Array elements and their memory locations

References

Referencing (&) and dereferencing (*) operators

The & and * operators are used for referencing and dereferencing. The & symbol is also used in C++ to define reference types, and as a bitwise AND operator. We can also use the asterisk (*) as an operator to dereference a pointer and as a multiplication operator.

• Referencing operator (&): The referencing operator is used to define referencing variable. A reference variable prepares an alternative (alias) name for previously defined variable. The syntax of the referencing operator is as follows.

  Syntax:

  Data-type & reference variable name = variable name;

  Example:

  int qty=10;

  int & qt=qty;

  Here, qty is already declared and initialized. The second statement defines an alternative variable name, that is, qt to variable qty. If both variables printed displays the same value. Any change made in one of the variable causes the change in both the variables.

  qt=qt*2;

  Now, contents of qt and qty will be 20.

  Note that the token & is not an address operator. The declaration int & indicates reference to data type int.

  Principles for declaring reference variable are as follows:

  1. A reference variable should be initialized.
  2. Once a reference variable is declared, it should not refer to any other variable. Once the actual variable and reference variable are connected, they are tied jointly congenitally.
  3. The reference variable can be created referring to pointer variable. The declaration is as follows:

     char * h=“C++”;

     char *&q=h;

  4. A variable can contain various references. Modifying the value of one of them will result a change in all other variables.
  5. Array of references is not allowed.
• Dereferencing operator (*): The asterisk (*) in a variable expression is used to declare a pointer to a given type. In the example,

  int *x; Where, x is a pointer of integer type.

  if the operand is a “pointer to function,” the result is a function designator. If the operand is a pointer to an object, the result is an lvalue indicating that object. In the following conditions, the result of indirection is undefined.

  1. The expression is a null pointer.
  2. The expression is the address of an automatic variable and execution and it is out of scope.

Difference between & and * operator

The & is a reference operator. It displays the address of a variable in the RAM. To display the address of the variable, it should be preceded by the variable name.

Example:

int b=10;

cout<<unsigned(&b);

The above statement displays the address of the integer variable b.

The operator * is used to display the value stored at the address of the variable.

Example:

int b = 10;

cout<<*(&b);

The above statements display the value of value stored at address of b, that is, value of b.

Fig. 4.11 Difference between & and * operator

As shown in Figure 4.11, the statement (a) displays the contents of variable b, the statement (b) displays the address of the variable b, and the statement (c) displays the value of variable b.

 

Explanation: In the above program, the variable qty is declared as integer variable and initialized with 10. The variable qt is declared as reference variable for variable qty. We can use variable qt to access the value of qty. Any change made in one of the variable changes the contents of both the variables. The contents of both variables and their addresses are always same. The variables qt and qty are modified using increment and decrement operator. But the contents and address printed of both variables are the same. Figure 4.12 explains the reference variable with respect to other variable.

Fig. 4.12 Reference variable

4.4.3   User-Defined Data Type

User-defined data types are structure and classes, union, and enumerated

Structure and Classes

(1) keyword struct: struct is a keyword and used to combine variables of different data types into a single record.

 

struct name: An optional tag name that defines the structure type.

structure variables: These are member variables and hold data

Though struct name and structure variables are noncompulsory, one of them should be present. Member variables in the structure are declared by naming a <data-type>, followed by one or more <variable-name> separated by commas.

A semicolon can separate variables of different data types.

 

The structure my_friend defines a variable containing two strings (fname and phone) and two integers (age and height)(Fig 4.13).

Fig. 4.13 Structure and its elements

To access elements in a structure, record selector (.) called as dot operator is used. For example

strcpy (friendA.fname,“Sachin”);

 

Explanation: In the above program, struct my_friend is defined with four member variables. Identifier A is an object of struct my_friend. The initialization of data members of struct is done using dot operator with object A. The cout statements display contents of object A.

 

(2) keyword class: The class is a new keyword introduced in C++. Its use is the same as struct keyword. To declare a class, following syntax is used.

 

Class keyword: It is one of the keywords class, struct, or union.

Class-name: It can be any unique name inside its scope.

Base classlist: If the class is derived class, then it follows the list of the base class(es). It is optional.

Member variable list: Defines the data member variables and member functions.

 

Reader may refer chapter 8 on class for more details.

Union

A union is same as compared to a struct, but the only difference is that it allows the user to declare variables that share the same memory space.

The union requires bytes that are equal to the number of bytes required for the largest members. For example, if the union contains char, integer, and long integer, then the number of bytes reserved in the memory for the union is 4 bytes

 

C++ will allocate sufficient storage in union variable number to hold the largest element in the union. The union member variables number.c and number.i use the same memory location. In this way, writing into one will replace the other. Member variables of a union are accessed in the same way as a struct.

 

Explanation: In the above program, ABC is the name of the union. a, num, f1 are the variables of char, int, and float, respectively. X is the variable associated with the union type. Dot (.) operator is used to access the variable of any data types.

Anonymous Unions

An anonymous union does not contain tag name. Elements of such union can be accessed without using tag name. Consider the following example.

 

Both the member variables of union have the same memory location. They can be accessed as follows:

K = 20;

j = 2.2;

The declaration should not declare a variable of the above union type. Following program illustrates the use of anonymous union.

 

Explanation: In the above program, anonymous union is declared. The union has two data member variables k as integer variable and f as a float variable. The union has no tag name; hence, it is called as anonymous union. The member variable of such a union can be accessed directly like normal variable. Both the variables hold the same memory location.

Enumerated Data Type

The enum is a keyword. It is used for declaring enumeration data types. The programmer can declare new data type and define the variables of these data types that can hold. For example, the user can define the material as new data type. Its variable may be solid, liquid, and gas. Thus the three values are restricted for this new data type. These enumeration data types are useful in switch() case statement.

The syntax for enumerated data type is as follows and it uses a keyword enum.

enum logical { false,true};

enum logical {true=2, false=4};

enum components{solid,liquid,gas};

This statement declares a user-defined data type. The keyword enum is followed by the tag name logical. The enumerators are the identifiers false and true. Their values are constant unsigned integers and start from 0. The identifier false refers to 0 and true to 1. The identifiers are not to be enclosed with quotation marks. Also note that integer constants are not permitted and we can start the constants as given in the second statement. In the second statement, true refers to 2 and false refers to 4. In the third statement, the components is the user-defined data type and the variables attached to it are solid, liquid, and gas.

The ANSI C++ and Turbo C++ allow us to declare variables of enum type.

 

We can also define enum without tag name. Consider the following example.

enum{yes, no};

Here, yes is 0 and no is 1 and can be used as int answer=yes.

 

Explanation: In the above program, enum data type logical is declared with two values, that is, false and true. The false contains value 0 and true contains the value 1. The cout statement displays the contents of true and false. True means 1 and false means 0.

4.5  OPERATORS IN C AND C++

Operator is an instruction to the compiler or interpreter specified by a single or double symbol to perform certain operation with constants.

Example:

5+10

Here, 5 and 10 are constants. The symbol ‘+’ is an operator that indicates the operation to be performed. The ‘+’ performs addition of numbers. The ‘+’ is a single operator.

int x = 5;

++x;

In the above example, the operator ++ is an increment operator. This operator adds one to the value of operand.

The types of operators (Fig. 4.14) with their symbols are described in Table 4.7.

Fig. 4.14 Types of operators

Table 4.7 Types of Operators

Type of Operators	Symbolic Representation
Arithmetic operators	+, −, *, /, and %
Relational operators	>, <, = =, >=.<=, and !=
Logical operators	&&, ||, and !
Increment and decrement operators	++ and −−
Assignment operators	=,+=,−=,*=,/=,<<=,>>=,&=,|=,^=
Bit wise operators	&, |, ^, >>, <<, and ~
Special operator	,
Conditional operators	? and :

C++ supports all operators of ‘C’ and C++ introduces new additional operators. The new operators are listed in Table 4.8.

Table 4.8 Operators in C++

Operators	Description
<<	Insertion operator
>>	Extraction operator
::	Scope access (or resolution) operator
::*	Pointer to member decelerator
−>*	Deference pointers to pointers to class members
.*	Deference pointers to class members
delete	Memory release operator
new	Memory allocation operator

The scope access (or resolution) operator :: (two colons) allows you to access a global (or file duration) name even if a local hides it redecoration of that name.

The .* and −>* operators represents deference pointers to class members and deference pointers to pointers to class members, respectively.

4.5.1   Precedence of Operators in C++

In the following operator precedence Table 4.9, the C++ operators are classified into 13 groups. The #1 group has the top (highest) precedence, group #2 (unary operators) takes second precedence, and so on to the comma operator, which has lowest precedence. The precedence of operator in C++ is shown in Table 4.9.

The operators within each category have equal precedence.

The unary (group #2), conditional (group #11), and assignment (group #12) operators associate right-to-left; all other operators associate left-to-right.

 

Table 4.9 Precedence of Operators in C++

# Group	Operator	Operation
1. Top	()	Function call
	[]	Array subscript
	−>	C++ indirect component selector
	::	C++ scope access/resolution
	.	C++ direct component selector
2. Unary	!	Logical negation (NOT)
	~	Bitwise (1’s) complement
	+	Unary plus
	−	Unary minus
	++	Pre-increment or post-increment
	−−	Pre-decrement or post-decrement
	&	Address
	*	Indirection
	sizeof	Returns size of operand, in bytes
	new	Dynamically allocates C++ storage
	delete	Dynamically de-allocates C++ storage
3. Multiplicative	*	Multiply
	/	Divide
	%	Remainder (modulus)
4. Member Access	.*	C++ dereference
	−>*	C++ deference
5. Additive	+	Binary plus
	−	Binary minus
6. Shift	<<	Shift left
	>>	Shift right
7. Relational	<	Less than
	<=	Less than or equal to
	>	Greater than
	>=	Greater than or equal to
8. Equality	==	Equal to
	!=	Not equal to
9. Bitwise	&	Bitwise AND
	^	Bitwise XOR
	|	Bitwise OR
10. Logical	&&	Logical AND
	||	Logical OR
11. Conditional	?:	(a ? x : y means “if a then x, else y”)
12. Assignment	=	Simple assignment
	*=	Assign product
	/=	Assign quotient
	%=	Assign remainder (modulus)
	+=	Assign sum
	-=	Assign difference
	&=	Assign bitwise AND
	^=	Assign bitwise XOR
	|=	Assign bitwise OR
	<<=	Assign left shift
	>>=	Assign right shift
13. Comma	,	Evaluate

All of the operators in this table can be overloaded except the following:

 

. C++ direct component selector

.* C++ dereference

:: C++ scope access/resolution

?: Conditional

4.5.2   Precedence of * and [ ] Operators

In C++, the statements * x[4] and (* x) [4] are not same because the * operator having lower precedence than the [ ] operator. Consider the following examples.

int *arr[5];

The above statement declares an array of five pointers and the following operation is invalid because the array name itself is an address and it is a constant. Hence, cannot be changed.

arr++; or ++arr;

int (* arr)[5]

The above declaration declares a pointer to an array of five elements. Hence, the operations such as arr++ and ++arr are not supported. The following program explains both these conditions.

 

Explanation: In the above program, an integer array a[3][3] is declared and initialized. The base address of array and number of rows are passed to the function display(). In function display(), d is a pointer. The base address received by the variable x is assigned to pointer d. Using nested for loops, the elements of array are displayed.

4.6  SCOPE ACCESS OPERATOR

Like C, the variables declared in ‘C++’ programs are totally different from other languages. We can use the same variable names in the ‘C++’ program in separate blocks. The two declarations of the same variable refer different memory locations. When we declare a variable, it is available only to specific part or block of the program. Remaining block or other functions cannot access the variable. The area or block of the ‘C++’ program from where the variable can be accessed is known as the scope of variables.

The scope access (or resolution) operator :: (two colons) allows programmer to access a global (or file duration) name even if it is hidden by a local re-declaration of that name.

 

Explanation: In the above program, the integer variable ‘a’ is declared before main() and initialized with 10. It is a global variable. In the function main(), re-declaration of ‘a’ is done and this time the variable ‘a’ is initialized with 20. The first cout statement displays the global value of variable ‘a’, that is, 10. In this statement :: scope access operator is used to access the global value of the variable ‘a’. The second cout statement displays the local value of the variable ‘a’, that is, 20. Figure 4.15 shows the use of scope access operator for accessing global variable.

Fig. 4.15 Scope access operator

4.7  NAMESPACE

Namespace is one of the new features introduced by the ANSI C++.

It is used by programmers to avoid name clashes when programmer uses more than one library. If duplicate name with a matching scope is found in two parts of the program then name clash occurs.

All the items within the namespace have public visibility and the items declared within the namespace must include the C++ standard library and directives like using namespace std;.

Syntax of namespace is very similar to the classes or struct. The keyword namespace is followed by a namespace name, an opening curly brace, and terminated with closing brace without semicolon.

Syntax of the namespace is as follows-

 

Explanation: In the above program, variables v and f are declared within the namespace and are accessed by using scope resolution operator (::).

 

Explanation: In the above program, two different namespaces are used. Variables declared within them are used for performing the mathematical operations such as addition and multiplication.

 

Explanation: In this program nesting of namespaces is used and the variables declared under it are accessed. Unnamed namespace is used and variable within it is assigned a value which is displayed.

 

Explanation: Two functions named as mul and div are taken in namespace. Arguments to the functions are passed from the main() and functions’ results are displayed.

4.8  MEMORY MANAGEMENT OPERATORS

In ‘C’ language, we have studied the function malloc(), calloc(), and realloc() to allocate memory dynamically at run-time in the program. The free() function is used to release the resources allocated by these functions. C++ allows us to use these functions. In additional, C++ provides operators which help us to allocate and release the memory in easy way than these functions. These new operators are new and delete. The new operator creates an object and delete destroys the object. These operators are easy in writing as compared to malice() and calloc(). The syntaxes for new and delete are illustrated with suitable programs.

Following are the advantages of new operator over the function malloc():

1. The new operator itself calculates the size of the object without the use of sizeof() operator.
2. It returns the pointer type. The programmers need not take care of its type casting.
3. The new operator allocates memory and initializes the object at once.
4. The new and delete operators are simple in syntax. They can be overloaded.

4.8.1   new Operator

Format of new operator is as follows:

pointer memory variable = new operator – data type[size];

Here, pointer memory variable is a pointer to the data type. The new operator allocates memory of specified type and returns back the starting address to the pointer memory variable. Here, the element size is optional and used when we allocation of memory space is required for user-defined data types such as arrays, classes, and structures. If the new operator fails to allocate the memory it returns NULL, which can be used to detect failure or success of new operator.

Examples:

• pv = new int;
• int *pv = new int (50);
• *p = new int [3]

In example (a), pv is a pointer variable of integer type. Once allocated, the pv contains the starting address. In example (b), 50 is assigned to pointer variable pv. In example (3), memory for 3 integers, that is, 6 bytes are assigned to pointer variable p. The example of new operator with arrays are as follows:

 

Explanation: In the above program, x is an integer pointer variable. The new operator allocates memory required for 10 integers, i.e. 20 bytes to pointer x as each integer occupies 2 bytes. new operator is used to replace the sizeof() operator.

4.8.2   delete Operator

The delete operator frees the memory allocated by the new operator. This operator is used when the memory allocated is no longer used in the program. The following syntax is used for the delete operator.

 

In example (a), the delete operator releases the memory allocated to pointer p. Example (b) is advantageous when we want to free the dynamically allocated memory of array. The new C++ compilers do not require element size.

 

Explanation: The above program shows allocation of memory by using new operator. The delete operator frees the memory allocated by the new operator.

 

Explanation: In the above program, p is an integer pointer variable. The new operator allocates memory required for three integers, i.e. 6 bytes to pointer p. The first for loop reads integer through the keyboard and stores the number at memory location pointed by p as shown in Figure 4.16. Each time, pointer p is incremented and it shows the next location of its type. The second for loop displays the number by applying the same logic. Before that the pointer is again set to the starting location by decrementing by 3. The delete operator releases the memory allocated by the new operator. Figure 4.16 shows the memory allocation of the different variable.

Fig. 4.16 Memory allocated by the different variables

In the output of the program, only starting memory location numbers are displayed.

4.8.3   sizeof()

The sizeof() operator is used to return size occupied in bytes in memory by the variable. The sizeof() operator in C++ displays different values as compared to C. The following program illustrates this.

 

Explanation: In the above program, a character constant is used, sizeof( ) operator. The size determined is 1 byte. The same program ‘C’ will display the size 2 bytes, because C and C++ reacts differently with data types. In C, ‘a’ character is considered as integer. Hence the size displayed is 2 whereas in C++, it is considered as a character.

The size is the space occupied in memory in bytes by the variable. It depends upon the data type of variable. Figure 4.17 describes the space occupied in the memory by the variable integer and float.

Example:

int x = 5;

float f = 3.14;

The integer variable occupies two bytes and float variable occupies four bytes in memory.

Fig. 4.17 Space occupied by the int and float

4.9  COMMENTS

In C++ a symbol // (double slash) is used as a comment symbol and there is no termination symbol. Comment begin with // symbol. A comment can be inserted anywhere in the line and whatever follows till the end of line is ignored. The C comment symbols /* and */ are also valid in C++.

Examples:

// This is a C++ comment style

/* The C comment style is also valid in C++. */

4.10  COMMA OPERATOR

In C, every statement of the program is terminated by semicolon (;). In C++ it is applicable and in addition C++ allows us to terminate a statement using comma operator after satisfying the following rules.

1. The variable declaration statements should be terminated by semicolon.
2. The statements followed by declaration statements like clrscr(), cin, and cout can be terminated by comma operator.
3. C++ permits declaration of variables at any point in program, but such declaration is not allowed in between the statements terminated by comma operator. The initialization of previously declared variables can be done.
4. The last statement of the program must be terminated by semicolon.

Consider the following programs.

 

Explanation: In function main(), the first two statements are terminated by comma operator and the last statement is terminated by semicolon.

All the above points are noticed in the Turbo C++ compiler. The reader is advised to follow his/her own observations.

 

Explanation: In the above program, the first and last statements are terminated by semicolon. Comma operator terminates the statements in between these two statements.

4.11  COMMA IN PLACE OF CURLY BRACES

The curly braces ({}) are used to define the body of function and scope of the control statements. The opening curly brace ({) indicates starting of the scope and closing curly (}) brace indicates the end of the scope. It is also possible to use comma operator in condition and loop statement in place of {} to indicate the scope of the statement. The use of comma operator is not allowed in definition of function. The following declaration is invalid.

 

The following program explains the use of comma operator with conditional and loop statements.

 

Explanation: In the above program, integer variable x is declared and initialized with 10. The if statement checks the value of x and executes respective blocks. The statements of if and else blocks are terminated by comma. The last statements of if block and else block are terminated by a semicolon to indicate the end of scopes. In this program, the if block is executed.

 

Explanation: In the above program, the statements terminated by comma are included in the scope of for loop. The first two statements are terminated by comma and the last statement is terminated by semicolon, that is end of scope of for loop.

4.12  MORE PROGRAMS

Explanation: In the above program, variable j is declared in two scopes, that is, local and global. The variable j declared before main() is a global variable and the variable j is declared inside the main() function is local. Both global and local variables are initialized with 11 and 12, respectively. The local variable j can be accessed directly. The local variable hides the existence of global variable. The global variable can be accessed using (::) the scope access operator. The scope access operator prefixed with variable name displays the value of global scope and similarly we can also change the value. The output shows the values of local and global variables.

 

Explanation: In the above program, the variable j is declared in three different scopes. First is defined in before main(), second is inside the main(), and the third one is also inside the main() but within another block. The first cout statement displays the values of variable j of local and global scope. The second cout statement that is inside the block displays the value of variable j local to the same block and the global variable declared before main(). The third statement produces the same output as the first.

 

Explanation: In the above program integer variable x is initialized to 15 and y is declared reference to variable x. The variable x and y refers to the same memory location and change in one variable can affects other. In the above program values of variable x and y are modified and values and address are displayed. From the output we notice that value and address of the variable x and y are displayed same.

 

Explanation: In the above program, the structure boy is declared before main() with two data members name and age of char and int data type, respectively. Two user-defined functions are defined as cstyle() and cppstyle(). In function main(), b1 and b2 are two variables of the struct boy type and they are initialized. The address of b1 is passed to the cstyle() function whereas cppstyle() needs only variable name. The cstyle() function receives address and stores it in the pointer. The cppstyle() function accept reference of the actual variable and stores it in the format variable. The code inside these functions directly replaces the old values with new ones. The result is displayed as per the output.

 

Explanation: In the above program, structure boys is declared. The objects b1 and b2 are declared of structure boys type. Both the structure variables are initialized. The function show() is declared and defined. The statement show()=b2; passes contents of b2 into function show(). The contents of variable b1 are displayed that is similar to b2. The function returns object b1 and again content of b1 is displayed.

 

Explanation: In the above program, variable r and area are of float type. The variable pi is constant and initialized to 3.14. The value of r is entered through the keyboard. Area of circle is calculated using the formula. The pow() function calculates the square of the variable r. The cout statement displays the area of the circle. The variable pi is constant and cannot be changed during the program execution.

 

Explanation: In the above program, integer x is a constant variable and initialized with 15. The variable y is a reference variable to variable x. We cannot change the value of x as it is a constant variable. But we can change the value of its reference variable. The change in reference variable does not change the value of constant variable. The output shows the values of both the variables.

 

Explanation: The above program is the same as previous one. In this program the reference is declared as constant. We cannot change the value of the reference variable. A change made in actual variable changes the value of the reference variable.

 

Explanation: In the above program, txt1 is a character pointer and initialized with the string “Eye”. The pointer txt2 is a reference variable to the character pointer txt1. The statement *txt1=‘B’; replaces the first character of the string with character ‘B’ and contents of both the pointers are displayed. The statement *txt2=‘d’; replaces the first character of the string with variable ‘d’ through the reference variable.

 

Explanation: In the above program, the function show() and pointer s are declared as constants. It is not possible to assign any data to pointer s because it is a constant. The function show() is invoked and it returns string. The returned string is assigned to pointer s. The content displayed is “Hello”.

 

Explanation: In the above program, variable s and pointer sp are declared in two scopes, that is, global and local. The address of global variables is assigned to both the local and global pointers sp using the following statements:

• int *sp=&s.;
• int *sp=&::s;

In statement (a), the address of global variable s is assigned to global pointer sp. In statement (b), the scope access operator is used to access the global variable and ampersand pre-fixed assigns address of global variable to local pointer sp. Thus, both the local and global pointers point to the same variable. The output indicates contents of individual variables and pointers and sum of local and global variables. The last sum result is 30 since both pointers point to the same variable, that is global variable.

 

Explanation: In the above program, G is a macro initialized with scope access operator. We can use G in place of (::) scope access operator. The variable loop is declared and initialized in two scopes (local and global). Using for loop repetitive division of global and local loop variable is performed and result is displayed.

 

Explanation: In the above program, integer a is declared and initialized with value 175. The pointer variable x is declared and initialized with address of variable a. The reference variable j is declared and value pointer x is assigned to it. The cout statement displays the values of a, j, and x. The value printed is 175. The integer variable q is declared and initialized with 147. Its address is assigned to pointer x and again q is initialized with 155. This time the values of a, j, and x displayed are 175,175, and 155, respectively. The value of pointer is altered but values of actual and reference variables are unaffected.

 

Explanation: In the above program, x is an integer variable and y is a float variable. The variable y is initialized with value 2.1. The values 15.2 and 85.13 are displayed by converting them to integer using type casting syntaxes.

The value of float y is assigned to integer variable x using type casting. The values of x and y are displayed on the screen. Again variable y is assigned with x + 1.5. The result will be 3.5 and not 3.6 because by applying float type cast we cannot convert an integer value to float.

1. C++ programs consist of objects, classes, functions, variables, and other statements.
2. The ‘C++’ keywords are reserved words by the compiler. All ‘C’ language keywords are valid in C++ and a few additional keywords by ANSI committee are also valid.
3. Identifiers are names of variables, functions, and arrays. They are user-defined names, consisting of a sequence of letters and digits, with a letter as a first character.
4. The constants in ‘C++’ are applicable to the values, which do not change during the execution of a program. The two types of constants are literal and symbolic.
5. C++ supports all data types of C.
6. The keywords signed, unsigned, short, and long are type modifiers. A type modifier changes the meaning of the base data type to produce a new data type.
7. The void type is an empty data type.
8. The enum is a keyword. It is used for declaring enumeration data types. C++ allows us to declare a variable of enum data type and enum without tag name.
9. Variable are used to store constants, that is, information. A variable is a sequence of memory locations, which are used to store the assigned constant.
10. C++ permits declaration of variables anywhere in the program.
11. The initialization of variable at run-time is called as dynamic initialization.
12. C++ supports all the operators of ‘C’. The list of newly introduced operators is described in this chapter.
13. The referencing operator is used to define referencing variable. A reference variable prepares an alternative (alias) name for a previously defined variable.
14. The asterisk (*) in a variable expression is used to declare a pointer to a given type.
15. The scope access (or resolution) operator :: (two colons) allows a programmer to access a global (or file duration) name even if it is hidden by a local re-declaration of that name.
16. The new operator creates an object and delete destroys the object. These operators are easy in writing as compared to malloc() and calloc().
17. C++ reference types, declared with & operator, are nearly identical but not exactly the same as the pointer types. They declare aliases for object variables and allow the programmer to pass arguments by reference to functions.
18. In C++, a symbol // (double slash) is used as a comment symbol and there is no termination symbol.

 

(A) Answer the following questions

1. Describe different parts of C++ programs.
2. List the new keywords in C++ with their functions.
3. What are identifiers, variables, and constants?
4. What are the two types of constants? Describe them with suitable examples.
5. Describe the statements for creating constants. Explain with examples.
6. Describe the use of keyword void? In how many ways can it be used with a function?
7. What is the difference between variable declaration in C and C++?
8. What is dynamic initialization? Is it possible in ‘C’?
9. Describe the use of scope access operator (::) and reference operator (&).
10. What are the advantages of new operator over malloc() function?
11. What are type modifiers? Why they are essential in C++?
12. Describe the types of derived data type.
13. Describe the following terms:
    • Precedence of operators in C++
    • Type modifiers
    • Constant pointers
14. What do you mean by namespace?
15. Explain the nesting of namespace with a suitable program.
16. What is the difference between namespace and class?
17. Write a short note on comma operator.

(B) Answer the following by selecting the appropriate option

1. In C++, the symbol used for writing comments is
   • //
   • //* *//
   • */ */
   • none of the above
2. The :: is known as
   • scope access operator
   • two colons
   • both (a) and (b)
   • none of the above
3. The scope resolution operator (::) is used to access the
   • local variables
   • global variables
   • both local and global variable
   • none of the above
4. The delete operator is used
   • to delete object
   • to delete file
   • both (a) and (b)
   • none of the above
5. The new and delete are
   • operators
   • keywords
   • both (a) and (b)
   • none of the above
6. The new operator
   • allocates memory
   • releases memory
   • both (a) and (b)
   • none of the above
7. The union declared without tag name is called as
   • anonymous union
   • nameless union
   • unknown union
   • void union
8. The symbol defined using #define are called
   • micro
   • small
   • macro
   • marco
9. What will be the output of the following program?

   #include<iostream.h>

   int main()

   {

   char *n;

   cout<<sizeof(n);

   return 0;

   }

   • 2
   • 1
   • 4
   • none of the above
10. What will be the value of c after execution of the following program?

    #include<iostream.h>

    void main()

    {

    int *p, c=0;

    p=new int[4];

     

    for (int x=0;x<2;x++)

    c=c+sizeof((p+x));

    cout<<c;

    }

    • 4
    • 8
    • 2
    • 0
11. What will be the output of the following program?

    #include<iostream.h>

    void main()

    {

    {

    for ( int i=0;i<5;i++)

    { cout<<i; }

    }

    cout<<“i =”<<i;

    }

    • 01234 i =5
    • undefined symbol i
    • 012345
    • none of the above
12. What will be the output of the following program?

    #include<iostream.h>

    #include<conio.h>

    union aa

    {

    int a;

    char b;

    float c;

    unsigned int d;

    double e;

    }z;

    int main()

    {

    clrscr();

    cout<<sizeof(z);

    return 0;

    }

    • 8
    • 4
    • 17
    • none of the above
13. What will be the output of the following program?

    #include<iostream.h>

    #include<conio.h>

    struct aa

    {

    int a;

    char b;

    float c;

    unsigned int d;

    double e;

    }z;

    int main()

    {

    clrscr();

    cout<<sizeof(z);

    return 0;

    }

    • 8
    • 4
    • 17
    • none of the above
14. What will be the output of the following program?

    #include<iostream.h>

    namespace aaa

    {

    int b=10;

    }

    int main()

    {

    cout<<b;

    }

    • garbage value
    • error
    • 10
    • none of the above
15. What will be the output of the following program?

    #include<iostream.h>

    namespace

    {

    char b=‘a’;

    }

    int main()

    {

    cout<<b;

    }

    • Error
    • a
    • garbage value
    • none of the above
16. What will be the output of the following program?

    #include<conio.h>

    #include<iostream.h>

    void main()

    {

    clrscr();

    float x=5.5,y=10.0,*p,*q,r;

    p=&x;

    q=&y;

    r=*p++*++*q/2;

    cout<<“ Value of r=”<<r;

    getch();

    }

    • 45.67
    • 30.25
    • 0
    • error
17. What will be the output of the following program?

    #include<iostream.h>

    #include<constream.h>

    const int tax=1000;

    void main()

    {

    clrscr();

    int value=10000;

    int cost;

    cost=tax+value;

    cout<<“ ”<<cost;

    getch();

    }

    • 11000
    • 1000
    • 11
    • 110
18. What will be the output of the following program?

    #include<iostream.h>

    #include<conio.h>

    void main()

    {

    clrscr();

    int *price= new

    int[1],var;

    *price=500,price++;

    price-=1;

    cout<<“Price :”;

    cout<<“ ”<<* price,delete price;

    }

    • 50
    • 500
    • 5000
    • 5

(C) Attempt the following programs

1. Write a program to allocate memory using new operator for 10 integers. Read and display the integers.
2. Write a program to evaluate the following series.
   • x=x²+x³+ --xⁿ
   • y=2^x+2*(x³−10)
   • z=x−y (use (a) and (b))
   • Display square root of z.
3. Write a program to display A to Z characters using while loop.
4. Write a program to draw a square box. Use for loop.
5. Write a program to declare and initialize a variable. Create a reference variable. Display the value of actual variable using reference variable.
6. Given the Van der Waals constants x and y for a gas, calculate the critical temperature, pressure, and volume using the following formulas.

   Ct = 8x/27Rb

   p = x/27b²

   v = 3b

   R = 0.0821 dm³atm/mol/k

   Read values of x and y and calculate and print the values of Ct, p, and v.

7. The sum of the square of the first n natural numbers is calculated by the formula sum=n (n+1)*(2n+1)/5. Read value of n through the keyboard and calculate the sum of square of first n natural numbers.
8. Write a program to calculate
   • Area of circle (area=3.12*r²)
   • Circumference of the circle (c=2*3.12*r)
   • Volume of the cylinder (v=3.12*r²*h)
   • Surface area of the closed cylinder (s=2*3.12*r*h+2*3.12*r²)
   • Volume of sphere (v=4/3*3.12*r³)
9. A company gives the following rates of commission for the monthly sales of the product.

   Below Rs. 15000 150001–20000 200001–30000 Above 30000

   No commission 5% 10% 12%

   Write a program to read the sales and display the commission.

10. Write a program to display the sum of odd numbers between 1 and 150.
11. A worker takes a job for 31 days. His pay for the first day is Rs. 20. His pay for the second day is Rs. 40. Pay for each day is twice what he gets the previous day. What will be the total pay for 31 days?
12. Write a program to find the range of the given numeric data.
    (Range: smallest number – largest number)
13. Write a program to find the factorial of entered name using namespace.