C++ Tutor

Linear Search Function

April 4th, 2011

#include <iostream>
using namespace std;

int linearSearch(const int[], int, int);

int main()
{
    const int arraySize=10;
    int a[arraySize]={3, 0, 11, -4, 45, 23, 343, 32, 0, 33};
    int key;
    cout<<"Enter integer search key: ";
    cin>>key;
    int index = linearSearch(a, key, arraySize);
    if(index !=-1)
               cout<<"Index where element lives is "<<index;
    else
               cout<<"Not there.";
    system("pause");
    return 0;
}

int linearSearch (const int array[], int key, int sizeOfArray)
{
    for(int i = 0; i <sizeOfArray; i++)
            if(array[i]==key)
                             return i;
    return -1;
}

Posted in functions, Sorting | No Comments »

cin.get() and cin.getline()

December 1st, 2010

#include <iostream>
using namespace std;

int main()
{
char line[25];
cout << " Type a line and hit Enter:";
cin.get( line, 25 );
cout << ' ' << line<<"\n";
cout<<"Only 25 characters will be returned.\n";
cout<<"**********************************************\n";
cout << " Type a line and endit it with @:";
cin.getline( line, 25, '@' );
cout << line;
cout<<"Only the last 25 characters will be returned.\n";
cout<<"**********************************************\n";
char text[]="story";
cout<<text<<"\n";
system("pause");
return 0;
}

Posted in .get(), cin and cout, getline() | No Comments »

Vectors

November 26th, 2010

#include <iostream>
#include <vector>
using namespace std;

void loadVector(vector <int> &);
void printVector(vector <int> &);
void loadArray(int[], int);
void printArray(int[], int);
bool equalArrays(int[], int, int[], int);

int main()
{
const int array1_length = 4, array2_length = 4 ;
vector <int > integerVector1(4), integerVector2(4);//Declare vector.
int integerArray1[4], integerArray2[4];//Declare array.
if (integerVector1==integerVector2)
cout<<"The two vectors are equal.\n";
else
cout<<"The two vectors are not equal.\n";
if (equalArrays(integerArray1, array1_length, integerArray2, array2_length))
cout<<"The two arrays are equal.\n";
else
cout<<"The two arrays are not equal.\n";

loadVector(integerVector1);
loadVector(integerVector2);

printVector(integerVector1);
printVector(integerVector2);

/* Note that the array function, undlike the vector function,
needs to be told the array's dimension. */
loadArray(integerArray1, array1_length);
loadArray(integerArray1, array2_length);

printArray(integerArray1, array1_length);
printArray(integerArray2, array2_length);

vector<int> integerVector3(integerVector1);
if (integerVector1==integerVector3)
cout<<"The old vector and the new vector are equal.\n";
else
cout<<"The old vector and the new vector are not equal.\n";
/* Unlike arrays, vectors have a mechanism for finding out if you have gone
beyond the array, using the at() function. */
integerVector1.at(2)=10;
//integerVector1.at(8)=100; This will generate an error.

system("pause");
return 0;
}

void loadVector(vector <int> &v)
{
/*Unlike the array, vector objects have a built-in size() function which
means that the vector size does not need to be imported. */
for (size_t i=0; i<v.size(); i++)
{
cout<<"Enter an integer: ";
cin>>v[i];
}
}

void printVector(vector <int> &v)
{
for (size_t i=0; i<v.size(); i++)
cout<<v[i]<<"\n";
}

void loadArray(int a[] , int length)
{
for (int i = 0; i<length; i++)
{
cout<<"Enter an integer: ";
cin>>a[i];
}
}

void printArray(int a[] , int length)
{
for(int i = 0; i<length; i++)
cout<<a[i]<<"\n";
}

bool equalArrays(int a1[] , int length1, int a2[] , int length2)
{
if (length1!=length2)
return false;
else
for(int i = 0; i<length1; i++)
{
if(a1[i]!=a2[i])
return false;
}
return true;
}

Posted in Uncategorized | No Comments »

Static Variables

November 24th, 2010

#include <iostream>
using namespace std;

int a = 0;
int b();

int main()
{
for (int i=1; i<=10; i++)
{
a++;
cout<<a<<" from the main function.\n";
cout<<b()<<" after calling the 'b' function.\n";
}
system("pause");
return 0;
}

int b()
{
static int a = 0;
a++;
return a;
}

Posted in functions, Global Variables | No Comments »

Global Variables II

November 24th, 2010

#include <iostream>
using namespace std;

int a = 0;
int b();

int main()
{
for (int i=1; i<=10; i++)
{
a++;
cout<<a<<" from the main function.\n";
cout<<b()<<" after calling the 'b' function.\n";
}
system("pause");
return 0;
}

int b()
{
int a = 0;
a++;
return a;
}

Posted in functions, Global Variables | No Comments »

Global Variables

November 24th, 2010

#include <iostream>
using namespace std;

int a = 0;
int b();

int main()
{
for ( class='keywords';>int i=1; i<=10; i++)
{
a++;
cout<<a<<" from the main function.\n";
cout<<b()<<" after calling the 'b' function.\n";
}
system("pause");
return 0;
}

int b()
{
a++;
return a;
}

Posted in functions, Global Variables | No Comments »

Function Demonstration

November 24th, 2010

#include <iostream>
using namespace std;

int answer(int, int);

int main()
{
    int a, b;
    cout<<"Enter two numbers: ";
    cin>>a>>b;
    cout<<"The answer is: "<<answer(a, b)<<"\n";
    system("pause");
    return 0;
}

int answer(int a, int b)
{
    if(a%2==0 && b%2==0)
         return 3*a+7*b;
    else
        return 2*a+5*b;
}

Posted in functions | No Comments »

Polymorphism I

November 15th, 2010

Go to File:

Fraction1.cpp
Fraction1.h
MixedNumber1.cpp
MixedNumber1.h
Main.cpp

Fraction1.cpp

#include "Fraction1.h"
#include <iostream>
using namespace std;

Fraction::Fraction()
{
//Initializes fractions to 1/2 by default.
numerator=1;
denominator=2;
}
Fraction::Fraction(int n, int d)
{
setNumerator(n);
setDenominator(d);
}
void Fraction::setNumerator(int input)
{
numerator=input;
}
void Fraction::setDenominator(int input)
{
if(input==0)
cout<<"You cannot have zero in the denominator.";
denominator=input;
}
int Fraction::getNumerator()
{
return numerator;
}
int Fraction::getDenominator()
{
return denominator;
}

void Fraction::displayFraction()
{
cout<<numerator<<"/"<<denominator<<"\n";
}

Fraction Fraction::operator*(Fraction f)
{
Fraction answerFraction;
answerFraction.setNumerator(f.numerator*numerator);
answerFraction.setDenominator(f.denominator*denominator);
return answerFraction;
}
Fraction Fraction::operator/(Fraction f)
{
Fraction answerFraction;
answerFraction.setNumerator(f.denominator*numerator);
answerFraction.setDenominator(f.numerator*denominator);
return answerFraction;
}
Fraction Fraction::operator+(Fraction f)
{
Fraction answerFraction;
answerFraction.setNumerator(f.denominator*numerator + f.numerator*denominator);
answerFraction.setDenominator(f.denominator*denominator);
return answerFraction;
}
Fraction Fraction::operator-(Fraction f)
{
Fraction answerFraction;
answerFraction.setNumerator(f.denominator*numerator - f.numerator*denominator);
answerFraction.setDenominator(f.denominator*denominator);
return answerFraction;
}
ostream &operator<<(ostream & cout, const Fraction &f)
{
if(f.denominator == 1 || f.numerator == 0)
cout<<f.numerator;
else
cout<<f.numerator<<"/"<<f.denominator<<"\n";
return cout;
}
istream &operator>>(istream & cin, Fraction &f)
{
cin>>f.numerator;
cin.ignore();
cin>>f.denominator;
return cin;
}
void Fraction::print() const
{
cout<<"The fraction "<<(*this)<<" is ";
if(numerator<denominator)
cout<<"proper.\n";
else
cout<<"improper.\n";
}

Fraction1.h

#ifndef FRACTION_H
#define FRACTION_H
#include <iostream>
using namespace std;

class Fraction
{
friend ostream &operator<<(ostream &, const Fraction &);
friend istream &operator>>(istream &, Fraction &);

public:
Fraction();
Fraction(int, int);
void setNumerator(int );
void setDenominator(int );
int getNumerator();
int getDenominator();
void displayFraction();
Fraction operator*(Fraction );
Fraction operator/(Fraction );
Fraction operator+(Fraction );
Fraction operator-(Fraction );
void print() const;
private:
int numerator;
int denominator;
};
#endif

MixedNumber1.cpp

#include "MixedNumber1.h"
#include "Fraction1.h"
#include <iostream>
using namespace std;

MixedNumber::MixedNumber(int w, int n, int d)
:Fraction( n, d)
{
setWhole(w);
}
MixedNumber::MixedNumber():Fraction()
{
//Initializes the whole number to 0.
whole=0;
}
void MixedNumber::setWhole(int w)
{
whole=w;
}
int MixedNumber::getWhole()
{
return whole;
}
void MixedNumber::displayMixedNumber()
{
cout<<whole<<" ";
/*I do not need to say <<numerator<<"/"<<denominator.
We can use displayFraction() from the Fraction class, of which
the current class, MixedFraction, is a subclass. */
displayFraction();
}
MixedNumber MixedNumber::operator*(MixedNumber &m)
{
Fraction f1, f2, f3;
MixedNumber m1;
f1=mixedNumberToImproperFraction();
f2=m.mixedNumberToImproperFraction();
f3=f1*f2;
m1.fractionToMixedNumber(f3);
return m1;
}
MixedNumber MixedNumber::operator/(MixedNumber & m)
{
Fraction f1, f2, f3;
MixedNumber m1;
f1=mixedNumberToImproperFraction();
f2=m.mixedNumberToImproperFraction();
f3=f1/f2;
m1.fractionToMixedNumber(f3);
return m1;
}
MixedNumber MixedNumber::operator+(MixedNumber &m)
{
Fraction f1, f2, f3;
MixedNumber m1;
f1=mixedNumberToImproperFraction();
f2=m.mixedNumberToImproperFraction();
f3=f1+f2;
m1.fractionToMixedNumber(f3);
return m1;
}
MixedNumber MixedNumber::operator-(MixedNumber &m)
{
Fraction f1, f2, f3;
MixedNumber m1;
f1=mixedNumberToImproperFraction();
f2=m.mixedNumberToImproperFraction();
f3=f1-f2;
m1.fractionToMixedNumber(f3);
return m1;
}
Fraction MixedNumber::mixedNumberToImproperFraction()
{
int n;
n = whole*getDenominator()+getNumerator();
Fraction f(n,getDenominator());
return f;
}
void MixedNumber::fractionToMixedNumber(Fraction &f)
{
whole=f.getNumerator()/f.getDenominator();
/* We cannot directly access the numerator and denominator data fields
of the Fractdion superclass objects, which are private.
We can, however, access their public functdions to access these
data fields indirectly. */
setNumerator(abs(f.getNumerator()%f.getDenominator()));
setDenominator(f.getDenominator());
}
void MixedNumber::print() const
{
cout<<"The mixed number "<<(*this)<<" is ";
if(whole==0)
cout<<"a fraction and not a mixed number.\n";
else
cout<<"indeed a mixed number.\n";
}

void MixedNumber::printMixedNumber()
{
cout<<whole<<" "<<getNumerator()<<"/"<<getDenominator();
}
ostream &operator<<(ostream &cout, const MixedNumber &m)
{
Fraction f=m;
if(m.whole==0)
cout<<f;
else
{
cout<<m.whole<<" ";
if(f.getNumerator()!=0)
cout<<f;
}
return cout;
}
istream &operator>>(istream &cin, MixedNumber &m)
{
int n, d;
cin>>m.whole;
cin.ignore();
cin>>n;
cin.ignore();
cin>>d;
m.setNumerator(n);
m.setDenominator(d);
return cin;
}

MixedNumber1.h

#ifndef MIXEDNUMBER_H
#define MIXEDNUMBER_H
#include "Fraction2.h"
#include <iostream>
using namespace std;

class MixedNumber : public Fraction
{
friend ostream &operator<<(ostream &, const MixedNumber &);
friend istream &operator>>(istream &, MixedNumber &);
public:
MixedNumber();
MixedNumber(int, int, int);
void setWhole(int );
int getWhole();
void displayMixedNumber();
MixedNumber operator*(MixedNumber & );
MixedNumber operator/(MixedNumber & );
MixedNumber operator+(MixedNumber & );
MixedNumber operator-(MixedNumber & );
Fraction mixedNumberToImproperFraction();
void fractionToMixedNumber(Fraction &);
void print() const;
void printMixedNumber();
private:
int whole;
};
#endif

Main.cpp

#include "Fraction2.h"
#include "MixedNumber2.h"
#include <iostream>
using namespace std;

int main()
{
Fraction fractionProper(5, 7), fractionImproper(7,5);
MixedNumber mixed(2, 4, 7), unmixed(0, 4, 9);
cout<<"Print fraction "<<fractionProper<<"\n";
fractionProper.print();
cout<<"Print fraction "<<fractionImproper<<"\n";
fractionImproper.print();
cout<<"Print mixed number "<<mixed<<"\n";
mixed.print();
cout<<"Print mixed number "<<unmixed<<"\n";
unmixed.print();

Fraction *fractionPointer;
MixedNumber *mixedNumberPointer;
fractionPointer = &fractionProper;
mixedNumberPointer=&mixed;
cout<<"***********************************************************\n";
cout<<"We store a Fraction object's address in a Fraction pointer\n";
cout<<"and a MixedNumber object's address in a MixedNumber pointer\n";
cout<<"fractionPointer->print();\n";
fractionPointer->print();
cout<<"mixedNumberPointer->print();\n";
mixedNumberPointer->print();
cout<<"Everything comes out as expected.\n";
/*Trying to have a Fraction class (base class) object access a MixedNumber
function will lead to an error.
fractionPointer->printMixedNumber();*/
cout<<"***********************************************************\n";
/*A MixedNumber object (derived class object) can be stored in a Fraction address
(base class object).*/
fractionPointer = &mixed;
/*Trying to store the address of a Fraction class (base class) object in a
MixedNumber (derived class) pointer yields an error.
mixedNumberPointer=&fractionProper; */
cout<<"We now store a MixedNumber object's address in a Fraction pointer.\n";
cout<<"We cannot store a MixedNumber object's address in a Fraction pointer\n";
cout<<"fractionPointer->print();\n";
fractionPointer->print();
cout<<"The MixedNumber stored in the Fraction pointer behaves like a Fraction object!\n";
cout<<"***********************************************************\n";

system("pause");
return 0;
}

Posted in Class, Inheritance | No Comments »

Polymorphism II

November 15th, 2010

Go to File:

Fraction2.cpp
Fraction2.h
MixedNumber2.cpp
MixedNumber2.h
Main.cpp

Fraction2.cpp

#include "Fraction2.h"
#include <iostream>
using namespace std;

void Fraction::displayFraction()
{
cout<<numerator<<"/"<<denominator<<"\n";
}

Fraction2.h

#ifndef FRACTION_H
#define FRACTION_H
#include <iostream>
using namespace std;

class Fraction
{
friend ostream &operator<<(ostream &, const Fraction &);
friend istream &operator>>(istream &, Fraction &);

public:
Fraction();
Fraction(int, int);
void setNumerator(int );
void setDenominator(int );
int getNumerator();
int getDenominator();
void displayFraction();
Fraction operator*(Fraction );
Fraction operator/(Fraction );
Fraction operator+(Fraction );
Fraction operator-(Fraction );
virtual void print() const;
private:
int numerator;
int denominator;
};
#endif

MixedNumber2.cpp

#include "MixedNumber2.h"
#include "Fraction2.h"
#include <iostream>
using namespace std;

MixedNumber2.h

#ifndef MIXEDNUMBER_H
#define MIXEDNUMBER_H
#include "Fraction2.h"
#include <iostream>
using namespace std;

class MixedNumber : public Fraction
{
friend ostream &operator<<(ostream &, const MixedNumber &);
friend istream &operator>>(istream &, MixedNumber &);
public:
MixedNumber();
MixedNumber(int, int, int);
void setWhole(int );
int getWhole();
void displayMixedNumber();
MixedNumber operator*(MixedNumber & );
MixedNumber operator/(MixedNumber & );
MixedNumber operator+(MixedNumber & );
MixedNumber operator-(MixedNumber & );
Fraction mixedNumberToImproperFraction();
void fractionToMixedNumber(Fraction &);
virtual void print() const;
void printMixedNumber();
private:
int whole;
};
#endif

Main.cpp

#include "Fraction2.h"
#include "MixedNumber2.h"
#include <iostream>
using namespace std;

Fraction *fractionPointer;
MixedNumber *mixedNumberPointer;
fractionPointer = &fractionProper;
mixedNumberPointer=&mixed;
cout<<"***********************************************************\n";
cout<<"We store a Fraction object's address in a Fraction pointer\n";
cout<<"and a MixedNumber object's address in a MixedNumber pointer\n";
cout<<"fractionPointer->print();\n";
fractionPointer->print();
cout<<"mixedNumberPointer->print();\n";
mixedNumberPointer->print();
cout<<"Everything comes out as expected.\n";
/*Trying to have a Fraction class (base class) object access a MixedNumber
function will lead to an error.
fractionPointer->printMixedNumber();*/
cout<<"***********************************************************\n";
/*A MixedNumber object (derived class object) can be stored in a Fraction address
(base class object).*/
fractionPointer = &mixed;
/*Trying to store the address of a Fraction class (base class) object in a
MixedNumber (derived class) pointer yields an error.
mixedNumberPointer=&fractionProper; */
cout<<"We now store a MixedNumber object's address in a Fraction pointer.\n";
cout<<"We cannot store a MixedNumber object's address in a Fraction pointer\n";
cout<<"fractionPointer->print();\n";
fractionPointer->print();
cout<<"The MixedNumber stored in the Fraction pointer behaves like a MixedNumber object!\n";
cout<<"***********************************************************\n";

system("pause");
return 0;
}

Posted in Class, Inheritance | No Comments »

C++ Tutor

Sorting

Linear Search Function

cin.get() and cin.getline()

Vectors

Static Variables

Global Variables II

Global Variables

Function Demonstration

Polymorphism I

Go to File:

Polymorphism II

Go to File:

Pages

Archives

Categories

Blogroll

Meta