C

C++ Lecture 3 Examples

// EXAMPLE 1

#include <iostream>

using namespace std;

bool getNumber( int& i )

{

cout << "enter a number ";

char inputString[ 128 ];

cin >> inputString;

i = atoi( inputString );

return true;

}

void main()

{

int number = 0;

getNumber( number );

cout << number << endl;

}

// EXAMPLE 2

#include <iostream>

using namespace std;

bool getNumber( float& f )

{

cout << "enter a floating point number ";

char inputString[ 128 ];

cin >> inputString;

f = atof( inputString );

return true;

}

bool getNumber( int& i )

{

cout << "enter an integer ";

char inputString[ 128 ];

cin >> inputString;

i = atoi( inputString );

return true;

}

bool getNumber( int& i, int& j, int& k )

{

cout << "enter 3 integers ";

char inputString1[ 128 ];

char inputString2[ 128 ];

char inputString3[ 128 ];

cin >> inputString1 >> inputString2 >> inputString3;

i = atoi( inputString1 );

j = atoi( inputString2 );

k = atoi( inputString3 );

return true;

}

void main()

{

int numberI = 0;

float numberF = 0.0f;

int a,b,c;

getNumber( numberI );

getNumber( numberF );

getNumber( a, b, c );

cout << "int number: " << numberI << endl;

cout << "float number: " << numberF << endl;

cout << "three numbers: " << a << " " << b << " " << c << endl;

}

// EXAMPLE 3

#include <iostream>

using namespace std;

const int MAX_STRING_LEN = 128;

class CarInfo

{

public:

float odometerReading;

float lifeTimeServiceCost;

float originalPrice;

char ownerName[MAX_STRING_LEN];

bool isCarALemon();

};

bool CarInfo::isCarALemon()

{

return ( lifeTimeServiceCost > originalPrice );

}

void main()

{

CarInfo aCar;

char inputString[MAX_STRING_LEN];

cout << "Owner's name: ";

cin >> aCar.ownerName;

cout << "How much did the car cost " << aCar.ownerName << " ?\n$";

cin >> inputString;

aCar.originalPrice = atoi( inputString );

cout << "How much has " << aCar.ownerName << " paid for vehicle service?\n$";

cin >> inputString;

aCar.lifeTimeServiceCost = atoi( inputString );

cout << aCar.ownerName << "'s car is " << ( aCar.isCarALemon() ? "a lemon" : "okay" ) << endl;

}

C++ Lecture 4 Examples

example 1

#include <iostream>

using namespace std;

class Student

{

private:

long id;

public:

long getID();

void setID( long );

};

long Student::getID()

{

return id;

}

void Student::setID( long inID )

{

id = inID;

}

void main()

{

Student student;

student.setID( 1 );

cout << " id: " << student.getID() << endl;

}

example 2

#include <iostream>

using namespace std;

class Student

{

private:

long id;

public:

Student(); // default constructor

Student( int ); // overloaded constructor

~Student(); // destructor

};

Student::Student()

{

id = 0;

cout << "default constructor called" << endl;

}

Student::Student( int inID )

{

id = inID;

cout << "overloaded constructor called" << endl;

}

Student::~Student()

{

cout << "destructor called ";

cout << "for student: " << id << endl;

}

void main()

{

Student student1;

Student student2( 1 );

cout << "doing stuff" << endl;

}

example 3

#include <iostream>

using namespace std;

class Student

{

private:

long id;

bool enrolled;

public:

long getID() { return id; }

Student& setID( long id ) { this->id = id; return *this; }

bool isEnrolled() { return enrolled; }

Student& setEnrolled( bool enrolled )

{ this->enrolled = enrolled; return *this; }

};

void main()

{

Student student;

student.setEnrolled( true ).setID( 1 );

}

example 4

#include <iostream>

using namespace std;

// constants

const int MAX_STRING_LENGTH = 256;

const int MAX_STUDENTS = 20;

// class Student interface

class Student

{

private:

static long studentCount;

static Student* studentList[ MAX_STUDENTS ];

char name[ MAX_STRING_LENGTH ];

bool enrolled;

long id;

public:

Student( char*, bool );

const char* getName();

void setName( char* );

bool isEnrolled();

void setEnrolled( bool );

long getID();

static Student* getStudentFromID( long id );

static long getStudentCount();

};

// class Student implmentation

Student::Student( char* name, bool enrolled )

{

setName( name );

setEnrolled( enrolled );

id = studentCount;

studentList[ Student::studentCount ] = this;

studentCount++;

}

const char* Student::getName()

{

return name;

}

void Student::setName( char* name )

{

strcpy( this->name, name );

}

bool Student::isEnrolled()

{

return enrolled;

}

void Student::setEnrolled( bool enrolled )

{

this->enrolled = enrolled;

}

long Student::getID()

{

return id;

}

// class Student static method implmentation

Student* Student::getStudentFromID( long id )

{

if ( ( id <= studentCount ) && ( id >= 0 ) )

{

return studentList[ id ];

}

else

{

return 0;

}

}

long Student::getStudentCount()

{

return studentCount;

}

// class Student static member initialization

long Student::studentCount = 0;

Student* Student::studentList[ MAX_STUDENTS ];

// main routine to demonstrate Student

void main()

{

// get students

cout << "Enter student information. Enter name as \"end\" to exit" << endl;

do

{

char name[ MAX_STRING_LENGTH ];

    bool enrolled;

    cout << "Student name:";

    cin >> name;

    if ( stricmp( name, "end" ) == 0 )

    break;

    cout << " enrolled?:";

    cin >> enrolled;

    new Student( name, enrolled );

}

while( true );

// print list of students

for( int i = 0; i < Student::getStudentCount(); i++ )

{

cout << "Student Record" << endl;

    cout << " name: " << Student::getStudentFromID(i)->getName() << endl;

    cout << " id: " << Student::getStudentFromID(i)->getID() << endl;

    cout << " enrolled:" << Student::getStudentFromID(i)->isEnrolled() << endl;

}

}

C++ Lecture 5 Examples

example 1 - Better String handling with Methods

#include <iostream>

using namespace std;

const int MAX_STRING = 256;

class MyString

{

private:

char string[ MAX_STRING ];

public:

MyString();

MyString( const char* );

const char* getString();

MyString& setString( const char* );

MyString& appendString( const char* );

bool isEqualTo( const char* );

};

MyString::MyString()

{

string[0] = '\0';

}

MyString::MyString( const char* string )

{

setString( string );

}

const char* MyString::getString()

{

return string;

}

MyString& MyString::setString( const char* string )

{

strcpy( this->string, string );

return *this;

}

MyString& MyString::appendString( const char* string )

{

strcat( this->string, string );

return *this;

}

bool MyString::isEqualTo( const char* string )

{

return ( strcmp( this->string, string ) == 0 );

}

void main()

{

MyString string1( "Hello" );

MyString string2( "Good bye" );

MyString string3;

string3.setString( string1.getString() );

string3.appendString( " and " ).appendString( string2.getString() );

if ( string1.isEqualTo( string2.getString() ) )

{

cout << "string1 == string2" << endl;

}

cout << string3.getString() << endl;

}

example 2 - Overloaded operators in a our Integer class

#include <iostream>

using namespace std;

class Integer

{

private:

int value;

public:

// Accessor methods

void setValue( int value )

{

    this->value = value;

}

int getValue()

{

    return value;

}

// Overloaded operators

Integer& operator=( const int setMe )

{

    value = setMe;

    return *this;

}

Integer operator+( const Integer& addMe )

{

    Integer temp;

    temp.value = value + addMe.value;

    return temp;

}

//Integer& operator+=( const int addMe )

//{

    //value = value + addMe;

    //return *this;

//}

Integer& operator+=( const Integer addMe )

{

    value = value + addMe.value;

    return *this;

}

Integer operator+( const int addMe )

{

    Integer temp;

    temp.value = value + addMe;

    return temp;

}

bool operator==( const Integer checkMe )

{

    if ( this->value == checkMe.value )

    {

      return true;

    }

    else

    {

      return false;

    }

}

bool operator!=( const Integer checkMe )

{

    if ( this->value != checkMe.value )

    {

      return true;

    }

    else

    {

      return false;

    }

}

// stream operators, declared as friends of class Integer

friend ostream& operator<< ( ostream& out, Integer printMe )

{

    out << "Integer is " << printMe.value;

    return out;

}

friend istream& operator>> ( istream& in, Integer& getMe )

{

    char temp[256];

    in >> temp;

    getMe.value = atoi( temp );

    return in;

}

};

// operator declared as non-member

const Integer operator+=( Integer& setMe, const int addMe )

{

setMe.setValue( setMe.getValue() + addMe );

return setMe;

}

void main()

{

Integer i;

Integer j;

i = 5;

j = i + 10;

i += 20;

cout << "Enter number :";

cin >> i;

cout << "Enter another number:";

cin >> j;

cout << i << " " << j << endl;

if ( i == j )

{

    cout << "i == j" << endl;

}

}

example 3 - Even better String handling with operator overloading

#include <iostream>

using namespace std;

const int MAX_STRING = 256;

class MyString

{

private:

char string[ MAX_STRING ];

public:

// constructors

MyString();

MyString( const char* );

// overloaded operators

const MyString& operator= ( const MyString myString );

const MyString& operator= ( const char* string );

MyString operator+ ( const MyString& myString );

MyString operator+ ( const char* string );

const MyString& operator+= ( const MyString myString );

const MyString& operator+= ( const char* string );

bool operator== ( const MyString myString );

friend ostream& operator<< ( ostream& out, MyString myString )

{

    return out << myString.string;

}

friend istream& operator>> ( istream& in, MyString& myString )

{

    return in >> myString.string;

}

};

MyString::MyString()

{

string[0] = '\0';

}

MyString::MyString( const char* string )

{

strcpy( this->string, string );

}

const MyString& MyString::operator= ( const MyString myString )

{

strcpy( this->string, myString.string );

return *this;

}

const MyString& MyString::operator= ( const char* string )

{

strcpy( this->string, string );

return *this;

}

MyString MyString::operator+ ( const MyString& myString )

{

return MyString( strcat( this->string, myString.string ) );

}

MyString MyString::operator+ ( const char* string )

{

return MyString( strcat( this->string, string ) );

}

const MyString& MyString::operator+= ( const MyString myString )

{

strcat( this->string, myString.string );

return *this;

}

const MyString& MyString::operator+= ( const char* string )

{

strcat( this->string, string );

return *this;

}

bool MyString::operator== ( const MyString myString )

{

return( strcmp( this->string, myString.string ) == 0 );

}

void main()

{

MyString string1;

MyString string2;

cout << "Enter string 1:";

cin >> string1;

cout << "Enter string 2:";

cin >> string2;

if ( string1 == string2 )

{

    cout << "string1 == string2" << endl;

}

else

{

    cout << "string1 != string2" << endl;

}

string1 = string1 + " " + string2;

cout << string1 << endl;

}

C++ Lecture 6 Examples

example 1 - Overloading the []

// DEMO - overloaded []

#include <iostream>

using namespace std;

class Integer

{

private:

int value;

char valueString[ 256 ];

int digits;

public:

Integer()

{

    setValue( 0 );

}

Integer( int value )

{

    setValue( value );

}

Integer& setValue( int value )

{

    this->value = value;

    itoa( value, this->valueString, 10 );

    this->digits = strlen( this->valueString );

    return *this;

}

int getDigits()

{

    return digits;

}

Integer& operator=( int value )

{

     setValue( value );

}

int operator[]( int index )

{

    if ( index > ( digits - 1 ) )

    {

      index = digits - 1;

    }

    if ( index < 0 )

    {

      index = 0;

    }

    return valueString[ index ] - 48;

}

};

void main()

{

Integer integer( 459874 );

for ( int i = 0; i < integer.getDigits(); i++ )

{

    cout << "digit " << i << " = " << integer[i] << endl;

}

}

example 2 - Overloading the ++

// DEMO - overloaded ++

#include <iostream>

using namespace std;

class Integer

{

private:

int value;

public:

Integer& operator=( int value )

{

    this->value = value;

    return *this;

}

Integer& operator++()

{

    this->value++;

    return *this;

}

Integer operator++( int )

{

    Integer temp = *this;

    this->value++;

    return temp;

}

friend ostream& operator<< ( ostream& out, Integer printMe )

{

    out << "Integer is " << printMe.value;

    return out;

}

};

void main()

{

Integer integer;

integer = 12;

cout << integer++ << endl;

cout << ++integer << endl;

}

example 3 - Standard Library - string class

// DEMO - string

#include <iostream>

#include <string>

using namespace std;

// basic string parsing demo

void main()

{

string inputString;

// user enters a string

cout << "Enter a string:";

cin >> inputString;

// split string at comma character

long splitAt;

// find the position of the first comma

while( ( splitAt = inputString.find_first_of( ',' ) ) != string::npos )

{

    // split off the first word seperated by a comma

    string temp = inputString.substr( 0, splitAt );

    // remove this first word from the input string

    inputString = inputString.substr( splitAt + 1, inputString.length() - splitAt - 1 );

    // print out the split off word

    cout << temp << endl;

}

// print what is left of the string

cout << inputString;

}

example 4 - Standard Library - string class 2

// DEMO - string 2, operators

#include <iostream>

#include <string>

using namespace std;

// basic string parsing demo

void main()

{

string inputString1;

string inputString2;

string combinedString;

// user enters a string

cout << "Enter word 1:"; cin >> inputString1;

cout << "Enter word 2:"; cin >> inputString2;

// overloaded string == operator

if ( inputString1 == "hello" )

{

cout << "aloha" << endl;

}

// overloaded string = and + operators

combinedString = inputString1 + " " + inputString2;

// print the combined string

cout << combinedString << endl;

}

example 5 - Standard Library - vector 1

// DEMO - vector with numeric

#include <iostream>

#include <vector>

#include <string>

using namespace std;

// basic string parsing demo

void main()

{

vector<int> arrayOfInts;

string inputString;

cout << "Enter numbers (enter \"end\" to stop)" << endl;

while ( true )

{

    cin >> inputString;

    if ( inputString == "end" )

      break;

    arrayOfInts.push_back( atoi( inputString.c_str() ) );

}

for ( int i = 0; i < arrayOfInts.size(); i++ )

{

    cout << arrayOfInts[ i ] << " ";

}

cout << endl;

}

example 6 - Standard Library - vector 2

// DEMO - vector with numeric and algorithm

#include <iostream>

#include <vector>

#include <string>

#include <algorithm>

using namespace std;

void getList( vector<int>& ints )

{

string inputString;

cout << "Enter numbers "

       << "(enter \"end\""

       << "to stop)" << endl;

while ( true )

{

    cin >> inputString;

    if ( inputString == "end" )

      break;

    ints.push_back( atoi( inputString.c_str() ) );

}

}

void printList( vector<int> ints )

{

for ( int i = 0; i < ints.size(); i++ )

{

    cout << ints[ i ] << " ";

}

cout << endl;

}

// basic string parsing demo

void main()

{

vector<int> arrayOfInts;

getList( arrayOfInts );

cout << "sorted" << endl;

sort( arrayOfInts.begin(), arrayOfInts.end() );

printList( arrayOfInts );

cout << "shuffled" << endl;

random_shuffle( arrayOfInts.begin(), arrayOfInts.end() );

printList( arrayOfInts );

}

example 7 - Standard Library - vector 3

// DEMO - vector with string and algorithm

#pragma warning(disable:4786)

#include <iostream>

#include <vector>

#include <string>

#include <algorithm>

using namespace std;

void getList( vector<string>& stringVect )

{

string inputString;

cout << "Enter words (enter \"end\" to stop)" << endl;

while ( true )

{

    cin >> inputString;

    if ( inputString == "end" )

      break;

    stringVect.push_back( inputString );

}

}

void printList( vector<string> stringVect )

{

for ( int i = 0; i < stringVect.size(); i++ )

{

    cout << stringVect[ i ] << " ";

}

cout << endl;

}

// basic string parsing demo

void main()

{

vector<string> arrayOfStrings;

getList( arrayOfStrings );

cout << "sorted" << endl;

sort( arrayOfStrings.begin(), arrayOfStrings.end() );

printList( arrayOfStrings );

cout << "shuffled" << endl;

random_shuffle( arrayOfStrings.begin(), arrayOfStrings.end() );

printList( arrayOfStrings );

}

C++ Lecture 7 Examples

example 1

// Basic Inheritance

#include <iostream>

#include <string>

using namespace std;

class Animal

{

public:

string name;

string sound;

};

class Dog : public Animal

{

public:

Dog()

{

    name = "Dog";

    sound = "Bark";

}

};

class Cat : public Animal

{

public:

Cat()

{

    name = "Cat";

    sound = "Meow";

}

};

void main()

{

Dog dog;

Cat cat;

cout << dog.name << endl;

cout << cat.name << endl;

}

example 2

// Protected members

#include <iostream>

#include <string>

using namespace std;

class Animal

{

private:

int count;

protected:

string name;

string sound;

public:

string getName() { return this->name; }

};

class Dog : public Animal

{

public:

Dog()

{

name = "Dog";

sound = "Bark";

}

};

void main()

{

Dog dog;

//cout << dog.name << endl;

cout << dog.getName() << endl;

}

example 3

// Access modifiers

#include <iostream>

#include <string>

using namespace std;

class Animal

{

public:

string name;

string sound;

};

class Dog : private Animal

{

public:

using Animal::name;

Dog()

{

name = "Dog";

sound = "Bark";

}

};

void main()

{

Dog dog;

cout << dog.name << endl;

}

example 4

// Overriding

#include <iostream>

#include <string>

using namespace std;

class Animal

{

public:

string name;

void produceSound() { cout << "no sound defined\n"; }

};

class Dog : public Animal

{

public:

Dog() { name = "Dog"; }

void produceSound() { cout << "woof\n"; }

};

class Cat : public Animal

{

public:

Cat() { name = "Cat"; }

};

void main()

{

Dog dog;

Cat cat;

dog.produceSound();

cat.produceSound();

}

example 5

// Pure Virtual

#include <iostream>

#include <string>

using namespace std;

class Animal

{

public:

string name;

virtual void produceSound() = 0;

};

class Dog : public Animal

{

public:

Dog() { name = "Dog"; }

void produceSound()

{

cout << "woof\n";

}

};

class Cat : public Animal

{

public:

Cat() { name = "Cat"; }

void produceSound()

{

cout << "meow\n";

}

};

void main()

{

Dog dog;

Cat cat;

dog.produceSound();

cat.produceSound();

}

example 6

// Multiple Inheritance

#include <iostream>

#include <string>

using namespace std;

class Animal

{

protected:

string name;

public:

virtual void produceSound() = 0;

};

class Dog : public Animal

{

public:

Dog() { name = "Dog"; }

void produceSound()

{

cout << "woof\n";

}

};

class Employee : public Animal

{

public:

float salary;

void produceSound()

{

cout << "let's have a meeting\n";

}

};

class PoliceDog :

public Dog,

public Employee

{

public:

void heal() { };

void attack() { cout << "attack\n"; };

using Dog::produceSound;

};

void main()

{

PoliceDog policeDog;

policeDog.produceSound();

policeDog.attack();

}

C++ Lecture 8 Examples

example 1

// Simple Polymorphism

#include <iostream>

#include <string>

using namespace std;

class Animal

{

public:

string name;

virtual void produceSound() = 0;

};

class Dog : public Animal

{

public:

Dog() { name = "Dog"; }

void produceSound()

{

    cout << "woof\n";

}

};

class Cat : public Animal

{

public:

Cat() { name = "Cat"; }

void produceSound()

{

    cout << "meow\n";

}

};

void main()

{

Animal* animals[2];

animals[0] = new Dog();

animals[1] = new Cat();

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

{

    animals[i]->produceSound();

}

}

example 2

// Polymorphism 2

#include <iostream>

#include <string>

using namespace std;

class Animal

{

public:

string name;

virtual void produceSound() = 0;

};

class Dog : public Animal

{

public:

Dog() { name = "Dog"; }

void produceSound() { cout << "woof\n"; }

};

class Cat : public Animal

{

public:

Cat() { name = "Cat"; }

void produceSound() { cout << "meow\n"; }

void scratch() { cout << "scratch\n"; }

};

void main()

{

Animal* animals[2];

animals[0] = new Dog();

animals[1] = new Cat();

animals[1]->scratch();

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

{

animals[i]->produceSound();

}

}

example 3

// Polymorphism - typeid

#include <iostream>

#include <string>

using namespace std;

class Animal

{

public:

string name;

virtual void produceSound() { cout << "no sound defined\n"; }

};

class Dog : public Animal

{

public:

Dog() { name = "Dog"; }

void produceSound() { cout << "woof\n"; }

};

class Cat : public Animal

{

public:

Cat() { name = "Cat"; }

};

void main()

{

Animal* animals[2];

animals[0] = new Dog();

animals[1] = new Cat();

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

{

cout << typeid( *animals[i] ).name() << " says ";

animals[i]->produceSound();

}

}

example 4

// Polymorphism - typeid and dynamic_cast

#include <iostream>

#include <string>

using namespace std;

class Animal

{

public:

string name;

virtual void produceSound() { cout << "no sound defined\n"; }

};

class Dog : public Animal

{

public:

Dog() { name = "Dog"; }

void produceSound() { cout << "woof\n"; }

};

class Cat : public Animal

{

public:

Cat() { name = "Cat"; }

void scratch() { cout << "scratch\n"; }

};

void main()

{

Animal* animals[2];

animals[0] = new Dog();

animals[1] = new Cat();

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

{

    cout << typeid( *animals[i] ).name() << " says ";

    animals[i]->produceSound();

    if ( typeid( *animals[i] ) == typeid( Cat ) )

    {

      dynamic_cast< Cat* >(animals[i])->scratch();

    }

}

}

example 5

// Simple Class Template with parameter

#include <iostream>

#include <string>

using namespace std;

template < typename SomeType, int size >

class Stack

{

private:

SomeType data[ size ];

int index;

public:

Stack() { index = 0; }

void putItemInList( SomeType item )

{

    if ( index < size )

      data[ index++ ] = item;

}

SomeType popItemFromList()

{

    if ( index > 0 )

    {

      return data[ --index ];

    }

    return data[0];

}

bool empty()

{

    return( index == 0 );

}

};

int main()

{

Stack< int, 10 > myIntStack;

Stack< string, 10 > myStringStack;

myIntStack.putItemInList( 1 );

myIntStack.putItemInList( 2 );

myIntStack.putItemInList( 3 );

while ( myIntStack.empty() == false )

    cout << myIntStack.popItemFromList()

         << endl;

myStringStack.putItemInList( "Once" );

myStringStack.putItemInList( "there" );

myStringStack.putItemInList( "was" );

while ( myStringStack.empty() == false )

    cout << myStringStack.popItemFromList()

         << endl;

return 0;

}

example 6

// More Advanced Class Template

#pragma warning(disable:4786)

#include <iostream>

#include <time.h>

#include <string>

#include <vector>

#include <functional>

#include <algorithm>

using namespace std;

template < class T >

class RandomDataPopper

{

private:

vector< T > data;

T returnMe;

public:

RandomDataPopper()

{

    srand( (unsigned)time( NULL ) );

}

static int random(int n)

{

    return rand() % n;

}

void addElement( T element )

{

    data.push_back( element );

    random_shuffle( data.begin(), data.end(),

      pointer_to_unary_function< int, int >(random) );

}

bool popElement( T& returnMe )

{

    if ( data.size() > 0 )

    {

      returnMe = data[0];

      data.erase( data.begin() );

      return true;

    }

    else

    {

      return false;

    }

}

long size()

{

    return ( data.size() );

}

};

void main()

{

RandomDataPopper<string> stringPopper;

stringPopper.addElement( string("Hello World!") );

stringPopper.addElement( string("Once upon a midnight dreary") );

stringPopper.addElement( string("640KB should be enough") );

stringPopper.addElement( string("I am the one") );

string output;

while( stringPopper.popElement( output ) )

{

    cout << output << endl;

}

}

example 7

// Streams - Console

#include <iostream>

#include <string>

using namespace std;

const int MAX_STRING = 10;

int main()

{

cout << "Please enter some characters:" << endl;

// let's take a look at the cin buffer without affecting it

char input = cin.peek();

if ( input > '0' && input < '9' )

{

    string input;

    cin >> input;

    int i = atoi(input.c_str());

    cout << "Number: " << i << endl;

}

else

{

    char input[ MAX_STRING ];

    cin.get( input, MAX_STRING );

    cout << "Text: " << input << endl;

}

return 0;

}

example 8

// Streams - File I/O

#include <iostream>

#include <fstream>

using namespace std;

int main()

{

// file output

ofstream myOutputFile( "file.test" );

myOutputFile << "Hello, this a file" << endl;

myOutputFile.close();

// file input

ifstream myInputFile( "file.test" );

cout << "my input file contains:\n" << myInputFile.rdbuf();

myInputFile.close();

return 0;

}

example 9

// Exceptions

#include <iostream>

using namespace std;

float divide( int a, int b )

{

if ( b != 0 )

    return ( a / b );

else

    return 0;

}

float divide2( int a, int b )

{

try

{

    return ( a / b );

}

catch ( ... )

{

    cout << "Error!" << endl;

    return 0;

}

}

int main()

{

divide2( 5, 0 );

return 0;

}