Scribd
Upload
62 views

C++ Features Constant Arguments

C++ allows for constant arguments that cannot be modified within a function. Constant arguments are useful when an argument is only used for output or on the right side of assignments. Constant references should also be used when arguments are passed by reference to prevent modification. Class functions can be managers for creation/destruction, accessors for retrieving state without modification, or mutators for altering state. Class instances are initialized using member initialization lists before constructors assign values. The "this" pointer references the instance calling an active class function.

Uploaded by

RahulSoni4u
Copyright
© Attribution Non-Commercial (BY-NC)
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
62 views

C++ Features Constant Arguments

C++ allows for constant arguments that cannot be modified within a function. Constant arguments are useful when an argument is only used for output or on the right side of assignments. Constant references should also be used when arguments are passed by reference to prevent modification. Class functions can be managers for creation/destruction, accessors for retrieving state without modification, or mutators for altering state. Class instances are initialized using member initialization lists before constructors assign values. The "this" pointer references the instance calling an active class function.

Uploaded by

RahulSoni4u
Copyright
© Attribution Non-Commercial (BY-NC)
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 5

C++ Features

Constant Arguments

The keyword const is added to the beginning of an argument declaration to prevent the
argument from being modified within the called function.
• This will also prevent temporary modification of the argument.

General guidelines as to when to use constant arguments:


• When the argument is used in an output statement only.
• When the argument is used on the right side of the assignment operator only.

void printValue( const int value ) { int updateValue( const int oldValue ) {
cout << value << endl; int value;
return; value = oldValue * 3;
} return value
// lower camel case naming }

In general an argument that uses Pass-by-Value should be constant.


• There are also times when an argument that uses Pass-by-Reference should be
constant.

An array is a perfect example.

int calculateSum( const int intArray[], const int size ) // Definition header

intArray is using Pass-by-Reference which means that it can be permanently modified


within calculateSum.
• Prevent this by passing intArray as a constant reference.

The copy constructor is another perfect example.

Stack::Stack( const Stack & oldStack ) // Definition header – .cpp file

oldStack is being copied to create a new Stack class instance.


• It is important that the state of oldStack is unchanged by the copy operation.

oldStack uses Pass-by-Reference so that the copy constructor is not called twice.
• Otherwise, the copy constructor is called once to create a temporary copy of oldStack
that is placed on the runtime stack and once to create the new Stack class instance.
Including Modules/Libraries in C++

Modules/libraries are used in C++ to declare and define Abstract Data Types. A module
in C++ consists of:
• a header file (.h)
• a implementation file (.cpp)

When adding a module to an application only include the header file and never include
the implementation file.

A simple application with one user-defined module will consist of:


• a driver/main file (.cpp)
• a module header file (.h)
• a module implementation file (.cpp).

Both the driver/main file and the implementation file will include the header file only.
• This will provide them both with the required declarations and definitions.

// standard module/library includes


#include <iostream>
// user-defined module/library includes
#include “gamradtkX.h” // driver.cpp & gamradtkX.cpp
using namespace std;
// rest of the driver/main file or the implementation file
Classification of Class Functions

Each class function can be classified in one of three categories:

1. Manager
a. Responsible for the creation and destruction of a class instance.
b. Examples: constructors and destructors
2. Accessor
a. Responsible for retrieving the state information of a class instance without
modifying its state.
b. These functions are commonly referred to as “getter” functions.
c. Examples: getValue, empty, full, print, peek
d. These function are generally constant functions
3. Mutator or Modifier
a. Responsible for altering the state information of a class instance.
b. These functions are commonly referred to as “setter” functions
c. Examples: setValue, push, pop

class Class1 { // header file


public:
Class1( ); // Manager
~Class1( ); // Manager
int getValue( ) const; // Accessor – returns values
void setValue( const int ); // Mutator – assigns values
private:
int value;
};

// implementation file
Class1::Class1( ) { Class1::~Class1( ) {
} }
int Class1::getValue( ) const { void Class1::setValue( const int oldValue ) {
return value; value = oldValue;
} return;
// upper camel case naming – MyClass }
Class Instantiation in C++

When a new class instance is created or a new class object is instantiated there are three
things that will automatically occur:

1. Storage allocation
2. Initialization using Base/Member initialization list
3. Assignment using the body of the constructor

The enforcement of constant members occurs between actions 2 and 3.

class Class2 { // header file


public:
Class2( ); // default constructor
~Class2( ); // destructor
private:
const int FIVE = 5; // ERROR
// Assignment must be performed in the body of the constructor
// Replace with: const int FIVE;
const int ZERO; // ERROR
// All constants must be initialized
};

Initialization is done using the Base/Member initialization list:

Class2::Class2( ) : FIVE( 5 ), ZERO( ) // Definition header – .cpp file


Class2::Class2( ) : FIVE( 5 ), ZERO( 0 ) // FIVE = 5 and ZERO = 0
// Also works with variables

class Class3 { // header file


public:
Class3( ); // default constructor
Class3( const Class3 & ); // copy constructor
~Class3( ); // destructor
private:
const int MAX_SIZE = 10; // ERROR
// Storage allocation is handled before constants are enforced
enum Limit { MAX_SIZE = 10 }; // OK
enum { MAX_SIZE = 10 }; // OK – doesn’t have to be named
int intArray[ MAX_SIZE ];
};
Referencing Multiple Class Instances

int main( ) { // driver/main file


// instance1 is calling/invoking the default constructor
Class3 instance1;
// instance2 is calling/invoking the overloaded/parameterized/
// copy constructor
Class3 instance2( instance1 );
return 0;
}

Class3::Class3( const Class3 & oldInstance ) { // implementation file


for ( int position = 0; position < MAX_SIZE; ++position )
intArray[ position ] = oldInstance.intArray[ position ];
}

intArray[ position ] // calling instance – instance2


// implicit reference to the instance being instantiated

oldInstance.intArray[ position ] // copied instance – instance1


// explicit reference to the existing instance

The “this” pointer is an explicit reference to the class instance that called the active class
function.

intArray[ position ] // calling instance – instance2

this->intArray[ position ] // alternative form using the “this” pointer

(*this).intArray[ position ] // alternative form using the “this” pointer

You might also like