Chapter 23: Keywords

virtual C++

1. The virtual keyword declares a virtual function or a virtual base class.

virtual [type-specifiers] member-function-declarator virtual [access-specifier] base-class-name

Parameters

1.type-specifiers Specifies the return type of the virtual member function.

2.member-function-declarator Declares a member function.

3.access-specifier Defines the level of access to the base class, public, protected or private. Can appear before or after the virtual keyword.

4.base-class-name Identifies a previously declared class type

this pointer

1.The this pointer is a pointer accessible only within the nonstatic member functions of a class, struct, or union type. It points to the object for which the member function is called. Static member functions do not have a this pointer.

this->member-identifier

An object's this pointer is not part of the object itself; it is not reflected in the result of a sizeof statement on the object. Instead, when a nonstatic member function is called for an object, the address of the object is passed by the compiler as a hidden argument to the function. For example, the following function call:

myDate.setMonth( 3 );

can be interpreted this way:

setMonth( &myDate, 3 );

The object's address is available from within the member function as the this pointer. Most uses of this are implicit. It is legal, though unnecessary, to explicitly use this when referring to members of the class. For example:

void Date::setMonth( int mn )

The expression *this is commonly used to return the current object from a member function: return *this; The this pointer is also used to guard against self-reference:

if (&Object != this) {

// do not execute in cases of self-reference

try, throw, and catch Statements (C++)

1.To implement exception handling in C++, you use try, throw, and catch expressions.

2.First, use a try block to enclose one or more statements that might throw an exception.

3.A throw expression signals that an exceptional condition—often, an error—has occurred in a try block. You can use an object of any type as the operand of a throw expression. Typically, this object is used to communicate information about the error. In most cases, we recommend that you use the std::exception class or one of the derived classes that are defined in the standard library. If one of those is not appropriate, we recommend that you derive your own exception class from std::exception.

4.To handle exceptions that may be thrown, implement one or more catch blocks immediately following a try block. Each catch block specifies the type of exception it can handle.

MyData md; try {

// Code that could throw an exception md = GetNetworkResource();

}

catch (const networkIOException& e) {

//Code that executes when an exception of type

//networkIOException is thrown in the try block

//...

//Log error message in the exception object cerr << e.what();

}

catch (const myDataFormatException& e) {

//Code that handles another exception type

//...

cerr << e.what();

}

// The following syntax shows a throw expression MyData GetNetworkResource()

{

// ...

if (IOSuccess == false)

throw networkIOException("Unable to connect"); // ...

if (readError)

throw myDataFormatException("Format error"); // ...

}

The code after the try clause is the guarded section of code. The throw expression throws—that is, raises—an exception. The code block after the catch clause is the exception handler. This is the handler that catches the exception that's thrown if the types in the throw and catch expressions are compatible.

try {

throw CSomeOtherException();

}

catch(...) {

//Catch all exceptions – dangerous!!!

//Respond (perhaps only partially) to the exception, then

//re-throw to pass the exception to some other handler

//...

throw;

}

friend (C++)