C & C++ Programs with output free

string length

2013-02-05T08:58:00.002-08:00

String length

This program prints length of string, for example consider the string "c programming" it's length is 13. Null character is not counted when calculating string length. To find string length we use strlen function of string.h.

C program to find string length

#include<stdio.h>
#include<string.h>
 
main()
{
   char a[100];
   int length;
 
   printf("Enter a string to calculate it's length\n");
   gets(a);
 
   length = strlen(a);
 
   printf("Length of entered string is = %d\n",length);
 
   return 0;
}

You can also find string length using pointer or without strlen function. Following program shows how to achieve this.

C program to find string length without strlen

C program to find length of a string using pointers.

#include<stdio.h>
 
main()
{
   char array[100], *pointer;
   int length = 0;
 
   printf("Enter a string\n");
   gets(array);
 
   pointer = array;
 
   while(*(pointer+length))
      length++;
 
   printf("Length of entered string = %d\n",length);
 
   return 0;
}

Function to find string length

int string_length(char *s)
{
   int c = 0;
 
   while(*(s+c))
      c++;
 
   return c;
}

c program for to add 2 matrix

2012-06-09T04:09:00.000-07:00

c program to add two matrix

This c program add two matrices i.e. compute the sum of two matrices and then print it. Firstly user will be asked to enter the order of matrix ( number of rows and columns ) and then two matrices. For example if the user entered order as 2, 2 i.e. two rows and two columns and matrices as
First Matrix :-
1 2
3 4
Second matrix :-
4 5
-1 5
then output of the program ( sum of First and Second matrix ) will be
5 7
2 9

C programming code

#include <stdio.h>
 
main()
{
   int m, n, c, d, first[10][10], second[10][10], sum[10][10];
 
   printf("Enter the number of rows and columns of matrix ");
   scanf("%d%d", &m, &n);
   printf("Enter the elements of first matrix\n");
 
   for ( c = 0 ; c < m ; c++ )
      for ( d = 0 ; d < n ; d++ )
         scanf("%d", &first[c][d]);
 
   printf("Enter the elements of second matrix\n");
 
   for ( c = 0 ; c < m ; c++ )
      for ( d = 0 ; d < n ; d++ )
            scanf("%d", &second[c][d]);
 
   for ( c = 0 ; c < m ; c++ )
      for ( d = 0 ; d < n ; d++ )
         sum[c][d] = first[c][d] + second[c][d];
 
   printf("Sum of entered matrices:-\n");
 
   for ( c = 0 ; c < m ; c++ )
   {
      for ( d = 0 ; d < n ; d++ )
         printf("%d\t", sum[c][d]);
 
      printf("\n");
   }
 
   return 0;
}

Add matrices program. Output of program:

C++ Lists: A Simple List Of Items

2012-05-28T19:02:00.002-07:00

Header File: List.h

//---------------------------------------------------------------------------

#ifndef ListH

#define ListH

//---------------------------------------------------------------------------

const int MaxItems = 100;

typedef double ItemType;



class FList

{

public:

    FList();

    virtual ~FList();

    int Count() const;

    bool Add(const ItemType NewItem);

    ItemType Retrieve(const int Pos);

    bool Delete(const int Pos);



private:

    int Counter;

    ItemType Item[MaxItems];

    const Index(const int Pos) const;

};

//---------------------------------------------------------------------------

#endif

Source File: List.cpp

//---------------------------------------------------------------------------

#pragma hdrstop



#include "List.h"

//---------------------------------------------------------------------------

#pragma package(smart_init)

FList::FList()

    : Counter(0)

{

}

//---------------------------------------------------------------------------

FList::~FList()

{

}//---------------------------------------------------------------------------

int FList::Count() const

{

    return Counter;

}

//---------------------------------------------------------------------------

const FList::Index(const int Pos) const

{

    return Pos-1;

}

//---------------------------------------------------------------------------

bool FList::Add(const ItemType NewItem)

{

    if( (Counter < 0) || (Counter > MaxItems) )

        return false;

    else

    {

        Item[Counter] = NewItem;

        Counter++;

        return true;

    }

}

//---------------------------------------------------------------------------

ItemType FList::Retrieve(const int Pos)

{

    if( (Pos < 0) || (Pos > Counter) )

        return 0;

    else

        return Item[Pos];

}

//---------------------------------------------------------------------------

bool FList::Delete(const int Pos)

{

    if( (Pos < 0) || (Pos > Counter) )

        return false;

    else

    {

        for(int i = Pos+1; i <= Counter; i++)

            Item[Index(i-1)] = Item[Index(i)];

        Counter--;

        return true;

    }

}

//---------------------------------------------------------------------------

Source File: Main.cpp

//---------------------------------------------------------------------------

#include <iostream>

#include <conio>

using namespace std;

#pragma hdrstop

#include "List.h"

//---------------------------------------------------------------------------



#pragma argsused

int main(int argc, char* argv[])

{

    FList List;



    List.Add(1240.42);

    List.Add(283.15);

    List.Add(42.48);

    List.Add(582.12);

    List.Add(60.14);

    List.Add(8022.28);



    cout << "List of items";

    for(int i = 0; i < List.Count(); i++)

        cout << "\nItem No." << i + 1 << ": " << List.Retrieve(i);

    cout << "\nNumber of items: " << List.Count() << " items\n\n";



    List.Delete(5);

    List.Delete(2);

    cout << "List of items";

    for(int i = 0; i < List.Count(); i++)

        cout << "\nItem No." << i + 1 << ": " << List.Retrieve(i);

    cout << "\nNumber of items: " << List.Count() << " items\n\n";



    cout << "Press any key to continue...";

    getch();

    return 0;

}

//---------------------------------------------------------------------------

Class Inheritance

2012-05-28T19:01:00.000-07:00

Inheritance is the ability for one class to receive its primary functionality from another class, also called its base class.

This example uses a class called Circle so that, given a radius, the program would calculate and display the diameter, the circumference, and the area.

Another class called Sphere is derived from the Circle class. This class can supply its own radius, display the same pieces of information as the Circle. Additionally, the Sphere class should calculate and display the volume.

This exercise uses different header and source files. It uses the following five files: circle.h, circle.cpp, sphere.h, sphere.cpp and exo.cpp.

Header File: circle.h

#ifndef CIRCLE_H

#define CIRCLE_H

struct Circle{

public:

Circle();

void setRadius(double r);

double getRadius();

 double Diameter();

 double Circumference();

 double Area();

 void Display();

protected:

double Radius;private:

};

#endif

Source File: circle.cpp

#include <iostream.h>

#include "circle.h"

const double PI = 3.14159;

Circle::Circle()

Radius = 0;

void Circle::setRadius(double r)

{ Radius = r <= 0 ? 1 : r;}

double Circle::getRadius()

{ return Radius;}

double Circle::Diameter(){

 return Radius * 2;}

double Circle::Circumference()

{ return Diameter() * PI;}

double Circle::Area(){

return Radius * Radius * PI;}

void Circle::Display()

{ cout << "\nCircle Properties";

 cout << "\nRadius        = " << getRadius();

 cout << "\nDiameter      = " << Diameter();

 cout << "\nCircumference = " << Circumference();

 cout << "\nArea          = " << Area() << "\n";

Header File: sphere.h

#ifndef SPHERE_H

#define SPHERE_H

struct Sphere : public Circle

{public:

double Volume();

 void Show();private:};

#endif

Source File: sphere.cpp

#include <iostream.h>

#include "circle.h"

#include "sphere.h"

const double PI = 3.14159;

double Sphere::Volume()

{ return Radius * Radius * Radius * PI * 4 / 3;

}void Sphere::Show(){

 cout << "\nCircle Properties";

 cout << "\nRadius        = " << getRadius();

cout << "\nDiameter      = " << Diameter();

 cout << "\nCircumference = " << Circumference();

 cout << "\nArea          = " << Area();

cout << "\nVolume        = " << Volume() << "\n\n";

Main File: exo.cpp

#include "circle.h"

#include "sphere.h"

void main(){

Circle circle;

 // Displaying a circle using the default value of the radius

circle.Display();

Circle circ;

// A circle with a value supplied for the radius

 circ.setRadius(12.50); circ.Display(); Sphere sphere;

 // A sphere that has its own radius, using the functions

 sphere.setRadius(8.95); // of the base class

 sphere.Show();

String Entering Example

2012-05-28T18:57:00.002-07:00

This example shows how to perform data entry on strings. The strings are simple array of characters and they are declared as member variables of a class. The class provides accessory methods for each member variable.

Header File: Person.h

//---------------------------------------------------------------------------
#ifndef PersonH
#define PersonH

//---------------------------------------------------------------------------
class TPerson
{
private:
    char* FirstName;
    char* LastName;
    char* Address;
    char* City;
     char* State;
    long  ZIPCode;

public:
    void  setFirstName(const char *FN);
    char* getFirstName() const { return FirstName; }
    void  setLastName(const char *LN);
    char* getLastName() const { return LastName; }
    char* FullName() const;
    void  setAddress(const char *Adr);
    char* getAddress() const { return Address; }
    void  setCity(const char *CT);
    char* getCity() const { return City; }
    void  setState(const char *St);
    char* getState() const { return State; }
    void  setZIPCode(const long ZIP);
    long  getZIPCode() const { return ZIPCode; }

    TPerson();
    TPerson(char *FName, char *LName, char *Adr,
            char *Ct, char *St, long  ZIP);
    TPerson(const TPerson &Pers);
    TPerson(char * FName, char * LName);
    virtual ~TPerson();
};
//---------------------------------------------------------------------------
#endif

Source File: Person.cppfont>

//---------------------------------------------------------------------------

#i#include <iostream>
using namespace std;

#pragma hdrstop

#include "Person.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)

//---------------------------------------------------------------------------

char *__fastcall TPerson::FullName() const
{
    char *FName = new char[40];
    strcpy(FName, FirstName);
    strcat(FName, " ");
    strcat(FName, LastName);

    return FName;
}
//---------------------------------------------------------------------------
__fastcall TPerson::TPerson()
    : ZIPCode(0)
{
    //TODO: Add your source code here  
    FirstName = new char[20];
    strcpy(FirstName, "John");
    LastName  = new char[20];
    strcpy(LastName, "Doe");
    Address   = new char[40];
    strcpy(Address, "123 Main Street Apt A");
    City      = new char[32];
    strcpy(City, "Great City");
    State     = new char[30];
    strcpy(State, "Our State");
}
//---------------------------------------------------------------------------
__fastcall TPerson::TPerson(char * FName, char * LName)
    : ZIPCode(0)
{
    //TODO: Add your source code here
    FirstName = new char[strlen(FName) + 1];
    strcpy(FirstName, FName);
    LastName  = new char[strlen(LName) + 1];
    strcpy(LastName, LName);
    Address   = new char[40];
    strcpy(Address, "123 Main Street Apt A");
    City      = new char[32];
    strcpy(City, "Great City");
    State     = new char[30];
    strcpy(State, "Our State");
} 
//---------------------------------------------------------------------------
__fastcall TPerson::TPerson(char *FName, char *LName, char *Adr,
                       char *Ct, char *St, long  ZIP)
    : ZIPCode(ZIP)
{                          
    //TODO: Add your source code here  
    FirstName = new char[strlen(FName) + 1];
    strcpy(FirstName, FName);
    LastName  = new char[strlen(LName) + 1];
    strcpy(LastName, LName);
    Address   = new char[40];
    strcpy(Address, Adr);
    City      = new char[32];
    strcpy(City, Ct);
    State     = new char[30];
    strcpy(State, St);
}
//---------------------------------------------------------------------------
__fastcall TPerson::TPerson(const TPerson &Pers)
    : ZIPCode(Pers.ZIPCode)
{              
    //TODO: Add your source code here
    FirstName = new char[strlen(Pers.FirstName) + 1];
    strcpy(FirstName, Pers.FirstName);
    LastName  = new char[strlen(Pers.LastName) + 1];
    strcpy(LastName, Pers.LastName);
    Address   = new char[strlen(Pers.Address) + 1];
    strcpy(Address, Pers.Address);
    City      = new char[strlen(Pers.City) + 1];
    strcpy(City, Pers.City);
    State     = new char[strlen(Pers.State) + 1];
    strcpy(State, Pers.State);
}
//---------------------------------------------------------------------------
void __fastcall TPerson::setFirstName(const char *FN)
{
    strcpy(FirstName, FN);
}
//---------------------------------------------------------------------------
void __fastcall TPerson::setLastName(const char *LN)
{
    strcpy(LastName, LN);
}
//---------------------------------------------------------------------------
void __fastcall TPerson::setAddress(const char *Adr)
{
    strcpy(Address, Adr);
}
//---------------------------------------------------------------------------
void  __fastcall TPerson::setCity(const char *CT)
{
    strcpy(City, CT);
}
//---------------------------------------------------------------------------
void  __fastcall TPerson::setState(const char *St)
{
    strcpy(State, St);
}
//---------------------------------------------------------------------------
void  __fastcall TPerson::setZIPCode(const long ZIP)
{
    ZIPCode = ZIP;
}
//---------------------------------------------------------------------------
__fastcall TPerson::~TPerson()
{
    //TODO: Add your source code here
    delete [] FirstName;
    delete [] LastName;
    delete [] Address;
    delete [] City;
    delete [] State;
}
//---------------------------------------------------------------------------

Main File: Main.cpp

////---------------------------------------------------------------------------
#include <iostream>
using namespace std;

#agma hdrstop

#i#include "Person.h"
//---------------------------------------------------------------------------

#pragma argsused

TPerson ProcessRegistration();
void DisplayInformation(const TPerson&);
//---------------------------------------------------------------------------
int main(int argc, char* argv[])
{
    TPerson Employee = ProcessRegistration();
    DisplayInformation(Employee);

    return 0;
}
//---------------------------------------------------------------------------
TPerson ProcessRegistration()
{
    char FName[12], LName[12];
    char Addr[40], CT[32], St[30];
    long ZC;

    cout << "Enter personal information\n";
    cout << "First Name: "; cin >> FName;
    cout << "Last Name:  "; cin >> LName;
    cout << "Address:    "; cin >> ws;
    cin.getline(Addr, 40);
    cout << "City:       ";
    cin.getline(CT, 32);
    cout << "State:      ";
    cin.getline(St, 30);
    cout << "Zip Code:   "; cin >> ZC;

    TPerson Pers(FName, LName, Addr, CT, St, ZC);
    return Pers;
}
//---------------------------------------------------------------------------
void DisplayInformation(const TPerson& Pers)
{
    cout << "\nEmployee Identification";
    cout << "\nFull Name: " << Pers.FullName();
    cout << "\nAddress:   " << Pers.getAddress();
    cout << "\nCity:      " << Pers.getCity() << ", "
         << Pers.getState() << " " << Pers.getZIPCode();
}
//---------------------------------------------------------------------------

Here is an example of running the program:

EnEnter personal information
First Name: Jeremy
Last Name:  Nguyen
Address:    1466 16th Street #B
City:       WashingtonState:      DC
ZZip Code:   20004

Employee Identification
Full Name: Jeremy Nguyenddress:   1466 16th Street #B
City:      Washington, DC 20004

This example shows to nest an object in another's body

2012-05-28T18:56:00.000-07:00

The C++ language allows you to create a class inside of another. This technique is referred to as nesting. At the time of this writing, nesting a class B inside of a class A doesn't give any access privilege of class A' member variables and methods to class B. Therefore, there is no major advantage to do it, only a matter of convenience and probably personal preference and opinion. It is said that the next C++ standard will allow a nested class B to have access to the private member variables and methods of the nesting class A.

(As you can see, this program was created in Borland C++ Builder. If you are using another compiler, remove the #pragma and probably the conio lines)

//---------------------------------------------------------------------------

#include <iostream>

#include <conio>

using namespace std;

#pragma hdrstop



//---------------------------------------------------------------------------



#pragma argsused

const int Maximum = 100;

//---------------------------------------------------------------------------

class TListOfStudents

{

public:

    class TStudent

    {

    private:

        string FullName;

        int    Age;

        char   Gender;

    public:

        void   setFullName(const string Name) { FullName = Name; }

        string getFullName() const { return FullName; }

        void   setAge(const int a) { Age = a; }

        int    getAge() const { return Age; }

        void   setGender(const char g) { Gender = g; }

        char   getGender() const { return Gender; }

        TStudent();

        TStudent(string FName, int a, char g);

        inline virtual ~TStudent() {}

    };

private:

    TStudent Item[Maximum];



public:

    TListOfStudents() : Count(0){}

    inline ~TListOfStudents() {}

    void Add(const TStudent& d);

    TStudent Retrieve(const int n);

    int Count;

};

//---------------------------------------------------------------------------

TListOfStudents::TStudent::TStudent()

{

    FullName = "";

    Age      = 0.00;

    Gender   = 'M';

}

//---------------------------------------------------------------------------

TListOfStudents::TStudent::TStudent(string FName, int a, char g)

{

    FullName = FName;

    Age      = a;

    Gender   = g;

}

//---------------------------------------------------------------------------

void __fastcall TListOfStudents::Add(const TStudent& d)

{

    if( Count < Maximum )

    {

 Item[Count] = d;

 Count++;

    }

}

//---------------------------------------------------------------------------

TListOfStudents::TStudent TListOfStudents::Retrieve(const int n)

{

    return Item[n];

}

//---------------------------------------------------------------------------

void __fastcall DisplayList(TListOfStudents &List);

void __fastcall CreateList(TListOfStudents &List);

//---------------------------------------------------------------------------

int main(int argc, char* argv[])

{

    TListOfStudents ListOfItems;



    CreateList(ListOfItems);

 

    DisplayList(ListOfItems);



    return 0;

}

//---------------------------------------------------------------------------

void CreateList(TListOfStudents &ListOfItems)

{

 TListOfStudents::TStudent Pupil;



 Pupil.setFullName("Harry Seamen");

 Pupil.setAge(12);

 Pupil.setGender('M');

 ListOfItems.Add(Pupil);



 Pupil.setFullName("Hermine Grand");

 Pupil.setAge(14);

 Pupil.setGender('F');

 ListOfItems.Add(Pupil);



 Pupil.setFullName("Ronald Hannah");

 Pupil.setAge(18);

 Pupil.setGender('M');

 ListOfItems.Add(Pupil);



 Pupil.setFullName("Johnny Hancock");

 Pupil.setAge(16);

 Pupil.setGender('M');

 ListOfItems.Add(Pupil);



}

//---------------------------------------------------------------------------

void DisplayList(TListOfStudents &ListOfItems)

{

 cout << "Full Name\tAge\tGender";

 string Gender[] = { "Male", "Female", "Unknown" };



 for(int i = 0; i < ListOfItems.Count; i++)

 {

  cout << "\n" << ListOfItems.Retrieve(i).getFullName()

       << "\t" << ListOfItems.Retrieve(i).getAge()

       << "\t";

  switch(ListOfItems.Retrieve(i).getGender())

  {

  case 'm':

  case 'M':

   cout << Gender[0];

   break;

  case 'f':

  case 'F':

   cout << Gender[1];

   break;

  default:

   cout << Gender[2];

  }

 }

}

//---------------------------------------------------------------------------

Here is an example of running the program:

Full Name       Age     Gender

Harry Seamen    12      Male

Hermine Grand   14      Female

Ronald Hannah   18      Male

Johnny Hancock  16      Male

This example uses anonymous Objects, that is, objects that don't have a name

2012-05-28T18:55:00.002-07:00

An anonymous class is one that doesn't have a name. In the following example, both structures inside the TRectangle union are anonymous classes:

//---------------------------------------------------------------------------

#include <iostream>

#include <conio>

using namespace std;

#pragma hdrstop



//---------------------------------------------------------------------------

#pragma argsused

// This rectangle can be identified by EITHER its location OR its dimensions

union TRectangle

{

    struct // Location

    {

        int x1;

        int y1;

        int x2;

        int y2;

    };

    struct // Dimensions

    {

        double Length;

        double Height;

    };

};

//---------------------------------------------------------------------------

int main(int argc, char* argv[])

{

    TRectangle Recto;

    char Choice;



    cout << "You want to identify your rectangle by "

         << "its location or its dimensions?";

    cout << "\n1 - Location";

    cout << "\n2 - Dimension";

    cout << "\nEnter your choice: ";

    cin >> Choice;



    if( Choice == '1' )

    {

        cout << "\nEnter the location of the rectangle on a "

             << "Cartesian coordinate system\n";

        cout << "First point\n";

        cout << "X coordinate: "; cin >> Recto.x1;

        cout << "Y coordinate: "; cin >> Recto.y1;

        cout << "Second point\n";

        cout << "X coordinate: "; cin >> Recto.x2;

        cout << "Y coordinate: "; cin >> Recto.y2;

        cout << "\nThe rectangle spans from A("

             << Recto.x1 << ", " << Recto.y1 << ") to B("

             << Recto.x2 << ", " << Recto.y2 << ").\n";

    }

    else if( Choice == '2' )

    {

        cout << "Enter the dimensions of the rectangle\n";

        cout << "Length: "; cin >> Recto.Length;

        cout << "Height: "; cin >> Recto.Height;

        cout << "\nDimensions of the rectangle";

        cout << "\nLength: " << Recto.Length;

        cout << "\nHeight: " << Recto.Height << endl;

    }

    else

        cout << "\nInvalid Choice";



    return 0;

}

//---------------------------------------------------------------------------

Here is an example of running the program:

You want to identify your rectangle by its location or its dimensions?

1 - Location

2 - Dimension

Enter your choice: 1



Enter the location of the rectangle on a Cartesian coordinate system

First point

X coordinate: -4

Y coordinate: 2

Second point

X coordinate: 5

Y coordinate: 1



The rectangle spans from A(-4, 2) to B(5, 1).



Press any key to continue...

An object as a member variable of another object

2012-05-28T18:53:00.001-07:00

This is an example of one object (the shape class implements a rectangle) being a member variable of another object (a brick).

Header File: shape.h

#ifndef _SHAPE_H

#define _SHAPE_H



class FRectangle

{

public:

 FRectangle(double l = 0, double w = 0)

  : Length(l), Width(w) {}

 void setLength(double lgt);

 void setWidth(double wdt);

 double getLength() const;

 double getWidth() const;

 double Perimeter() const;

 double Area() const;

 void Properties();

private:

 double Length;

 double Width;

};



#endif // _SHAPE_H

Source File: shape.cpp

#include <iostream.h>

#include "shape.h"



void FRectangle::setLength(double lgt)

{

 Length = lgt;

}



void FRectangle::setWidth(double wdt)

{

 Width = wdt;

}



double FRectangle::getLength() const

{

 return Length;

}



double FRectangle::getWidth() const

{

 return Width;

}



double FRectangle::Perimeter() const

{

 return 2 * (Length + Width);

}



double FRectangle::Area() const

{

 return Length * Width;

}



void FRectangle::Properties()

{

 cout << "\nRectangle characteristics";

 cout << "\n\tLength    = " << Length;

 cout << "\n\tWidth     = " << Width;

 cout << "\n\tPerimeter = " << Perimeter();

 cout << "\n\tArea      = " << Area() << endl;

}

Header File: brick.h

#ifndef BRICK_H_

#define BRICK_H_



#include "shape.h"



class Brick

{

public:

 Brick() {}

 void setThickness(double Tck);

 void setDimensions(double l, double w, double t);

 void setColor(char* clr);

 void setTexture(char* txr);

 char* getColor() const;

 char* getTexture() const;

 double Volume() const;

 void Display();

private:

 FRectangle shape;

 char* Color;

 char* Texture;

 double Thickness;

};



#endif // BRICK_H_

Source File: brick.cpp

#include <iostream.h>

#include "brick.h"



void Brick::setThickness(double Tck)

{

 Thickness = Tck;

}



void Brick::setColor(char* clr)

{

 Color = clr;

}



void Brick::setTexture(char* txr)

{

 Texture = txr;

}



void Brick::setDimensions(double l, double w, double t)

{

 shape.setLength(l);

 shape.setWidth(w);

 setThickness(t);

}



char* Brick::getColor() const

{

 return Color;

}



char* Brick::getTexture() const

{

 return Texture;

}



double Brick::Volume() const

{

 return shape.getLength() * shape.getWidth() * Thickness;

}



void Brick::Display()

{

 cout << "\nBrick characteristics";

 cout << "\n\tLength   = " << shape.getLength();

 cout << "\n\tWidth    = " << shape.getWidth();

 cout << "\n\tArea     = " << shape.Area();

 cout << "\n\tVolume   = " << Volume();

 cout << "\n\tColor    = " << getColor();

 cout << "\n\tTextture = " << getTexture();

 cout << endl;

}

Main File: Exo.cpp

#include "shape.h"

#include "brick.h"



void main()

{

 Brick brick;



 brick.setDimensions(12.50, 8.75, 5.55);

 brick.setColor("Bone White");

 brick.setTexture("Early Breeze");



 brick.Display();

}

Here is an example of running the program:

Brick characteristics

        Length   = 12.5

        Width    = 8.75

        Area     = 109.375

        Volume   = 607.031

        Color    = Bone White

        Textture = Early Breeze

An object declared as an array

2012-05-28T18:48:00.002-07:00

This example show how to declare and use an array of an object

#include <iostream>
using namespace std;

struct Paper
{
public:
    void GetDimensions();
    void Properties();

private:
    double Perimeter() const;
    double Area() const;
    double Height;
    double Width;
};

void Paper::GetDimensions()
{
    cout << "Enter the dimensions of the label\n";
    cout << "Height: ";
    cin >> Height;
    cout << "Width: ";
    cin >> Width;
}

void Paper::Properties()
{
    cout << "\n\tHeight    = " << Height;
    cout << "\n\tWidth     = " << Width;
    cout << "\n\tPerimeter = " << Perimeter();
    cout << "\n\tArea      = " << Area();
    cout << "\n\n";
}

double Paper::Perimeter() const
{
 return 2 + (Height * Width);
}

double Paper::Area() const
{
 return Height * Width;
}

void main()
{
    int Samples;
    Paper Label[100];

    cout << "How many sample labels do you want? ";
    cin >> Samples;

    for(int i = 0; i < Samples; ++i)
        Label[i].GetDimensions();

    cout << "\n\nHere are the characteristics of your labels\n";
    for(int j = 0; j < Samples; ++j)
    {
        cout << "Label No. " << j;
        Label[j].Properties();
    }
}

Here is an example of running the program:

How many sample labels do you want? 2

Enter the dimensions of the label
Height: 3.25
Width: 3.25

Enter the dimensions of the label
Height: 2.15
Width: 4.55


Here are the characteristics of your labels

Label No. 0
        Height    = 3.25
        Width     = 3.25
        Perimeter = 12.5625
        Area      = 10.5625

Label No. 1

        Height    = 2.15
        Width     = 4.55
        Perimeter = 11.7825
        Area      = 9.7825

An object as a function argument

2012-05-28T18:45:00.002-07:00

This example demonstrates how an object can be made an argument of a function.

#include <iostream.h>

struct Paper

{

 double Width;

 double Height;

};



void MagazineCover(Paper ppr)

{

    cout << "Characteristics of this piece of paper";

    cout << "\nWidth     = " << ppr.Width;

    cout << "\nHeight    = " << ppr.Height;

    cout << "\nPerimeter = " << 2 + (ppr.Width + ppr.Height);

    cout << "\nArea      = " << ppr.Width * ppr.Height;

}



int main(int argc, char* argv[])

{

    double w, h;



    cout << "Provide the dimensions of the magazine cover\n";

    cout << "Width: ";

    cin >> w;

    cout << "Height: ";

    cin >> h;



    Paper Cover = {w, h};

    MagazineCover(Cover);



    getchar();

    return 0;

}

Initializing the Members of a Class Using a Constructor

2012-05-28T18:43:00.000-07:00

This example uses a class that contains a constructor used to initialize the object. The class is called ShoeBox. When supplied with a length, a height, and a width, the object should calculate and display the total area of all sides and the volume.

Header File: shoebox.h

#ifndef SHOEBOX_H

#define SHOEBOX_H

class ShoeBox{

public:

ShoeBox(double l, double h, double w);

 double getLength() const;

double getHeight() const;

double getWidth() const;

void Properties();

double Area() const;

double Volume() const;

private:

double Length;

double Height;

double Width;

};

#endif

Source File: shoebox.h

#include <iostream.h>

#include "box.h"

ShoeBox::ShoeBox(double l, double h, double w)

{ Length = l;

 Height = h;

Width  = w;

double ShoeBox::getLength() const

{ return Length;

double ShoeBox::getHeight() const

{ return Height;

}double ShoeBox::getWidth() const{

 return Width;}

double ShoeBox::Area() const

return 2 * ((Length * Height) + (Height + Width) + (Length * Width));

}double ShoeBox::Volume() const

{ return Length * Height * Width;

}void ShoeBox::Properties(){

 cout << "Properties of the shoe box";

 cout << "\nLength = " << getLength();

cout << "\nHeight = " << getHeight();

cout << "\nWidth  = " << getWidth();

cout << "\nArea   = " << Area();

cout << "\nVolume = " << Volume() << "\n\n";

Header File: cube.h

#include "box.h"

void main()

{ ShoeBox Size6(8.65, 4.25, 4.15);

 Size6.Properties();

Here is a result of running the program

Properties of the shoe boxLength = 8.65

Height = 4.25

Width  = 4.15

Area   = 162.12

Volume = 152.564

A Simple Class

2012-05-28T18:37:00.000-07:00

Exercise

Write a simple class called Cube. The object should calculate the total area and
the volume based on the side measurement. If the program supplies a side
equal or lower than 0, reset the side to 1. Create an empty constructor and an
empty destructor. Implement the object in different files.

Header File: cube.h

#ifndef CUBE_H

#define CUBE_H

class Cube

{public:

Cube();

~Cube();

 void setSide(double s);

 double getSide();

double Area();

double Volume();

 void Properties();private:

 double Side;};

#endif

Source File cube.cpp

#include <iostream.h>

#include "cube.h"

Cube::Cube(){}

Cube::~Cube(){}

void Cube::setSide(double s)

{ Side = s <= 0 ? 1 : s;

}double Cube::getSide()

{ return Side;

}double Cube::Area()

{ return 6 * Side * Side;}

double Cube::Volume()

{ return Side * Side * Side;}

void Cube::Properties(){

cout << "Characteristics of this cube";

cout << "\nSide   = " << getSide();

cout << "\nArea   = " << Area();

cout << "\nVolume = " << Volume() << "\n\n";

Main File: Exo.cpp

#include "cube.h"

void main()

Cube cube;

 cube.setSide(-12.55);

cube.Properties();

 Cube de;

de.setSide(28.15);

 de.Properties();

Here is an example of the result:

Characteristics of this cubeSide   = 1

Area   = 6

Volume = 1

Characteristics of this cubeSide   = 28.15

Area   = 4754.53

Volume = 22306.7

Greatest Common Divisor 2

2012-05-28T18:30:00.002-07:00

#include <iostream>
using namespace std;

int GCD(int a, int b)
{
    while( 1 )
    {
        a = a % b;
  if( a == 0 )
   return b;
  b = b % a;

        if( b == 0 )
   return a;
    }
}

int main()
{
 int x, y;

 cout << "This program allows calculating the GCD\n";
 cout << "Value 1: ";
 cin >> x;
 cout << "Value 2: ";
 cin >> y;

 cout << "\nThe Greatest Common Divisor of "
      << x << " and " << y << " is " << GCD(x, y) << endl;  

 return 0;
}

Greatest Common Divisor

2012-05-28T18:28:00.002-07:00

#include <iostream>
using namespace std;

int GCD(int a, int b)
{
    int Remainder;

    while( b != 0 )
    {
        Remainder = a % b;
        a = b;
        b = Remainder;
    }

    return a;
}

int main()
{
 int x, y;

 cout << "This program allows calculating the GCD\n";
 cout << "Value 1: ";
 cin >> x;
 cout << "Value 2: ";
 cin >> y;

 cout << "\nThe Greatest Common Divisor of "
      << x << " and " << y << " is " << GCD(x, y) << endl;  

 return 0;
}

Passing an Object as Argument

2012-05-28T18:20:00.002-07:00

This example demonstrates how an object can be made an argument of a function.

#include <iostream.h>

struct Paper

{

 double Width;

 double Height;

};



void MagazineCover(Paper ppr)

{

    cout << "Characteristics of this piece of paper";

    cout << "\nWidth     = " << ppr.Width;

    cout << "\nHeight    = " << ppr.Height;

    cout << "\nPerimeter = " << 2 + (ppr.Width + ppr.Height);

    cout << "\nArea      = " << ppr.Width * ppr.Height;

}



int main(int argc, char* argv[])

{

    double w, h;



    cout << "Provide the dimensions of the magazine cover\n";

    cout << "Width: ";

    cin >> w;

    cout << "Height: ";

    cin >> h;



    Paper Cover = {w, h};

    MagazineCover(Cover);



    getchar();

    return 0;

}

Passing Arguments

2012-05-28T10:17:00.000-07:00

#include <iostream.h>

void main(){

 int Boys = 3, Girls = 5;

void PassByValue(int males, int females);

 void Reference(int &m, int &f);

void Pointers(int *u, int *v);

cout << "At startup, within main()"; 
cout << "\n\tBoys  = " << Boys;

 cout << "\n\tGirls = " << Girls;

cout << "\nPassing arguments by value = Copy";

 PassByValue(Boys, Girls);

 cout << "\nAfter calling PassByValue(), within main()";

 cout << "\n\tBoys  = " << Boys;

 cout << "\n\tGirls = " << Girls;

 cout << "\nPassing arguments by reference";

Reference(Boys, Girls);

cout << "\nAfter calling Reference(), within main()";

 cout << "\n\tBoys  = " << Boys;

 cout << "\n\tGirls = " << Girls;

cout << "\nPassing arguments pointers";

 Pointers(&Boys, &Girls);

 cout << "\nAfter calling Pointers(), within main()";

cout << "\n\tBoys  = " << Boys;

cout << "\n\tGirls = " << Girls;

 cout << "\n";}

void PassByValue(int b, int g)

{ b += 3, g += 4;

cout << "\nWithin PassByValue(), now";

cout << "\n\tBoys  = " << b;

cout << "\n\tGirls = " << g;}

void Reference(int &b, int &g)
{ b = b + 8, g = g + 5;

 cout << "\nWithin Reference(), now";

 cout << "\n\tBoys  = " << b;

 cout << "\n\tGirls = " << g;}

void Pointers(int *b, int *g){

*b = 44, *g = 52;

cout << "\nWithin Pointers(), now";

 cout << "\n\tBoys  = " << *b;

 cout << "\n\tGirls = " << *g;}

Passing Arguments by Value

2012-05-28T10:03:00.002-07:00

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

string GetName()
{
    string FirstName, LastName, FN;   

    cout << "Employee's First Name: ";
    cin >> FirstName;
    cout << "Employee's Last Name: ";
    cin >> LastName;  

    FN = FirstName + " " + LastName;

    return FN;
}

int main()
{
    string FullName;
    double Hours;

    double GetHours(string FullName);

    FullName = GetName();

    Hours = GetHours(FullName);

    cout << "\nEmployee's Name: " << FullName;
    cout << "\nWeekly Hours: " << Hours << " hours\n\n";

    return 0;
}

double GetHours(string FullName)
{
    double Mon, Tue, Wed, Thu, Fri, TotalHours;   

    cout << endl << FullName << "'s Weekly Hours\n";
    cout << "Monday: ";
    cin >> Mon;
    cout << "Tuesday: ";
    cin >> Tue;
    cout << "Wednesday: ";
    cin >> Wed;
    cout << "Thursday: ";
    cin >> Thu;
    cout << "Friday: ";
    cin >> Fri;  

    TotalHours = Mon + Tue + Wed + Thu + Fri;

    return TotalHours;
}

C++ Examples: If-Else

2012-05-28T10:00:00.002-07:00

Exercise

The LeVan Car Rental company charges $0.25/mile if the total mileage does not exceed
100.If the total mileage is over 100, the company charges $0.25/mile for the first 100
miles, thenit charges $0.15/mile for any additional mileage over 100. Write a program
so that if the clerk enters the number of miles, the program would display the total price owed.

#include <iostream>
using namespace std;

void main()
{
    unsigned int Miles;
    const double LessThan100 = 0.25;
    const double MoreThan100 = 0.15;
    double PriceLessThan100, PriceMoreThan100, TotalPrice;

    cout << "Enter the number of miles: ";
    cin >> Miles;

    if(Miles <= 100)
    {
        PriceLessThan100 = Miles * LessThan100;
        PriceMoreThan100 = 0;
    }
    else
    {
        PriceLessThan100 = 100 * LessThan100;
        PriceMoreThan100 = (Miles - 100) * MoreThan100;
    }

    TotalPrice = PriceLessThan100 + PriceMoreThan100;

    cout << "\nTotal Price = $" << TotalPrice << "\n\n";
}

Here is an example of running the program:

Enter the number of miles: 75

Total Price = $18.75

Press any key to continue

A Simple C++ Program

2012-05-28T09:57:00.003-07:00

This is the simples C++ program. It displays a sentence on the console or the terminal

Version 1

#include <iostream>
using namespace std;

int main()
{
 std::cout << "Welcome to the wonderful world of C++!!!\n";

 return 0;

}

Version 2

#include <iostream>
using namespace std;

int main()
{
 cout << "Welcome to the wonderful world of C++!!!\n";

 return 0;
}

C program to shutdown or turn off computer

2012-05-28T00:35:00.002-07:00

C Program to shutdown your computer: This program turn off i.e shutdown your computer system. Firstly it will asks you to shutdown your computer if you press 'y' the your computer will shutdown in 30 seconds, system function of "stdlib.h" is used to run an executable file shutdown.exe which is present in C:\WINDOWS\system32 in Windows XP. You can use various options while executing shutdown.exe for example -s option shutdown the computer after 30 seconds, if you wish to shutdown immediately then you can write "shutdown -s -t 0" as an argument to system function. If you wish to restart your computer then you can write "shutdown -r".

If you are using Turbo C Compiler then execute your file from folder. Press F9 to build your executable file from source program. When you run from within the compiler by pressing Ctrl+F9 it may not work.

C programming code for Windows XP

#include <stdio.h>
#include <stdlib.h>
 
main()
{
   char ch;
 
   printf("Do you want to shutdown your computer now (y/n)\n");
   scanf("%c",&ch);
 
   if (ch == 'y' || ch == 'Y')
      system("C:\\WINDOWS\\System32\\shutdown -s");
 
   return 0;
}

C programming code for Windows 7

#include <stdio.h>
#include <stdlib.h>
 
main()
{
   char ch;
 
   printf("Do you want to shutdown your computer now (y/n)\n");
   scanf("%c",&ch);
 
   if (ch == 'y' || ch == 'Y')
      system("C:\\WINDOWS\\System32\\shutdown /s");
 
   return 0;
}

To shutdown immediately use "C:\\WINDOWS\\System32\\ shutdown /s /t 0". To restart use /r instead of /s.

C programming code for Ubuntu Linux

#include <stdio.h>
 
int main() {
  system("shutdown -P now");
  return 0;
}

You need to be logged in as root user for above program to execute otherwise you will get the message shutdown: Need to be root, now specifies that you want to shutdown immediately. '-P' option specifes you want to power off your machine. You can specify minutes as:
shutdown -P "number of minutes"
For more help or options type at terminal: man shutdown.

c program to get ip address

2012-05-28T00:34:00.000-07:00

This c program prints ip (internet protocol) address of your computer, system function is used to execute the command ipconfig which prints ip address, subnet mask and default gateway. The code given below works for Windows xp and Windows 7. If you are using turbo c compiler then execute program from folder, it may not work when you are working in compiler and press Ctrl+F9 to run your program.

C programming code

#include<stdlib.h>
 
main()
{
   system("C:\\Windows\\System32\\ipconfig");
   system("pause");
 
   return 0;
}

IP address program executable.
Output of program: ( In Windows XP )

c program to print date

2012-05-28T00:26:00.002-07:00

This c program prints current system date. To print date we will use getdate function.

C programming code

#include<stdio.h>
#include<conio.h>
#include<dos.h>
 
main()
{
   struct date d;
 
   getdate(&d);
 
   printf("Current system date is %d/%d/%d",d.da_day,d.da_mon,d.da_year);
   getch();
   return 0;
}

Output of program

c program to add two complex numbers

2012-05-28T00:16:00.002-07:00

c program to add two complex numbers :- This program calculate the sum of two complex numbers which will be entered by the user and then prints it. User will have to enter the real and imaginary parts of two complex numbers. In our program we will add real parts and imaginary parts of complex numbers and prints the complex number, i is the symbol used for iota. For example if user entered two complex numbers as (1 + 2i) and (4 + 6 i) then output of program will be (5+8i). A structure is used to store complex number.

C programming code

#include <stdio.h>
 
struct complex
{
   int real, img;
};
 
main()
{
   struct complex a, b, c;
 
   printf("Enter a and b where a + ib is the first complex number.\n");
   printf("a = ");
   scanf("%d", &a.real);
   printf("b = ");
   scanf("%d", &a.img);
   printf("Enter c and d where c + id is the second complex number.\n");
   printf("c = ");
   scanf("%d", &b.real);
   printf("d = ");
   scanf("%d", &b.img);
 
   c.real = a.real + b.real;
   c.img = a.img + b.img;
 
   if ( c.img >= 0 )
      printf("Sum of two complex numbers = %d + %di\n",c.real,c.img);
   else
      printf("Sum of two complex numbers = %d %di\n",c.real,c.img);
 
   return 0;
}

Download add complex numbers program executable.
Output of c program to add two complex numbers is shown in image below :-

c program to add two complex numbers

2012-05-28T00:15:00.000-07:00

C programming code

#include <stdio.h>
 
struct complex
{
   int real, img;
};
 
main()
{
   struct complex a, b, c;
 
   printf("Enter a and b where a + ib is the first complex number.\n");
   printf("a = ");
   scanf("%d", &a.real);
   printf("b = ");
   scanf("%d", &a.img);
   printf("Enter c and d where c + id is the second complex number.\n");
   printf("c = ");
   scanf("%d", &b.real);
   printf("d = ");
   scanf("%d", &b.img);
 
   c.real = a.real + b.real;
   c.img = a.img + b.img;
 
   if ( c.img >= 0 )
      printf("Sum of two complex numbers = %d + %di\n",c.real,c.img);
   else
      printf("Sum of two complex numbers = %d %di\n",c.real,c.img);
 
   return 0;
}

Download add complex numbers program executable.
Output of c program to add two complex numbers is shown in image below :-

c program to generate random numbers

2012-05-28T00:14:00.000-07:00

c program to generate random numbers

This c program generates random numbers using random function, randomize function is used to initialize random number generator. If you don't use randomize function then you will get same random numbers each time you run the program.

C programming code using rand

#include <stdio.h>
#include <stdlib.h>
 
int main() {
  int c, n;
 
  printf("Ten random numbers in [1,100]\n");
 
  for (c = 1; c <= 10; c++) {
    n = rand()%100 + 1;
    printf("%d\n", n);
  }
 
  return 0;
}

C programming code using random function(Turbo C compiler only)

#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
 
main()
{
   int n, max, num, c;
 
   printf("Enter the number of random numbers you want ");
   scanf("%d",&n);
 
   printf("Enter the maximum value of random number ");
   scanf("%d",&max);
 
   printf("%d random numbers from 0 to %d are :-\n",n,max);
   randomize();
 
   for ( c = 1 ; c <= n ; c++ )
   {
      num = random(max);
      printf("%d\n",num);
 
   }
 
   getch();
   return 0;
}