namespace
/* namespace */
#include <iostream> namespace constants
{
static float pi = 3.14159;
/* a constant put in a constants namespace */
};
int main()
{
std::cout << "namespace constants " << constants::pi << "\n";
return 0;
}
/* basic circle class */
#include <iostream>
using namespace std;
static float pi = 3.14159;
class CCircle
{
private:
/*
* private member vars aren't available outside the class ;
* you have to change their values with public properties or methods
*/
float r;
public:
/* public 2nd half of our two part 'constructor' */
void create (float);
/* cast our area as a float, * returns double */
float area()
{
return (float)
pi * r * r;
}
};
/*
=======================================================================================================================
this will handle arguments for our constructor ;
I usually put method def with method declaration inside the class ;
but this shows how you can have the method def outside of a class, ;
resolving with ::
=======================================================================================================================
*/
void CCircle::create(float ir)
{
r = ir;
};
int main()
{
cout << " creating the circle \n";
CCircle mycircle;
cout << " area after default constructor " << mycircle.area() << "\n";
mycircle.create(13.1);
cout << " area of a circle after create " << mycircle.area() << "\n";
return 0;
};
/*
* class with constructor overload ;
* demonstrates using a class constructor and overloads ;
* of that constructor
*/
#include <iostream>
using namespace System;
using namespace std;
static float pi = 3.14159;
class Circle /* class def */
{
private:
float r;
public:
/* create a func to return the private r */
float radius()
{
return r;
};
/* incoming r constructor overload */
Circle(float ir)
{
r = ir;
}
/* default constructor r = 1 overload */
Circle()
{
r = 1;
}
/*
* cast our area as a float for no reason at all except it looks cool to ;
* put (float) in front of a var or expression
*/
float area()
{
return (float)
pi * r * r;
}
};
int main()
{
cout << " creating default circle \n";
/* the new default constructor makes the radius 1 */
Circle mycircle;
cout << " default r/area " << mycircle.radius() << "," << mycircle.area() << "\n";
cout << " creating another circle \n";
Circle mycircle2(3);
cout << " new r/area " << mycircle2.radius() << "," << mycircle.area() << "\n";
return 0;
/* you can resolve namespace members with :: */
};
/*
* Enumerated type. Enums by default assign integer values to the list members. ;
* running the program demonstrates the values of myobj and the enums of polys
*/
#include <iostream>
enum polys
{
square, rectangle, circle
};
polys myobj;
int main()
{
myobj = circle;
std::cout << "myobj " << myobj << "\n";
std:: cout << "myobj == circle " << ((myobj == circle) ? "true" : "false") << "\n";
std::cout << "myobj == 2 " << ((myobj == 2) ? "true" : "false") << "\n";
std::cout << polys::circle;
}
/*
* try-catch block example ;
* in which an error is introduced. Set the value of mybuff ;
* to something other than 21 to see program without errors
*/
#include <iostream>
using namespace std;
void main()
{
try
{
char *mybuff;
mybuff = new char[256];
mybuff = "21";
if (atoi(mybuff) == 21) throw "Invalid value for mybuff";
printf("No errors...");
}
/* end try */
catch(char * e)
{
printf("Error %s\n", e);
}
/* end catch */
finally
{
printf("This is always executed \n");
} /* end finally */
}
destructors
/*
* destructor ~classname ;
* if the class calls another class and this class is closed ;
* you can end up with a memory leak. In the destructor, you'd ;
* want to clean up subclass' stuff with delete etc.
*/
#include <iostream>
using namespace std;
class star
{
class weird
{
public: double myval;
};
private:
char *stype;
double mass;
double radius;
weird *myweird;
public:
star(char * istype, double imass, double iradius)
{
stype = istype;
mass = imass;
radius = iradius;
myweird = new weird;
};
void tostring()
{
printf ("%s,%s,%s\n", stype, mass.ToString(), radius.ToString ());
}
~star()
{
delete myweird;
/* put necessary clean up code in here */
}
};
void main()
{
cout << "creating a star object \n";
star mystar("Sun", 1, 1);
cout << "using the tostring() func to display contents of class " ;
mystar.tostring();
cout << "\n the instance will be destroyed (along with *myweird, \nusing the destructor) now in 5,4,3...\n";
}
/* static and dynamic casts */
#include <iostream>
class form
{
private:
int h, w;
public:
form(int ih, int iw)
{
h = ih;
w = iw;
};
};
class formbtn :
public form
{
private:
bool button;
public:
formbtn(int ih, int iw, bool inbtn)
:
form(ih, iw)
{
button = inbtn;
};
};
void main()
{
form form1(1, 1);
formbtn form2(2, 2, false);
formbtn * fv = dynamic_cast < formbtn * > (&form2);
form * fv2 = static_cast < formbtn * > (&form2);
/*
* formbtn* fv3 = dynamic_cast<formbtn*>(&form1);
* //compile fails bc form1 is not a derived class
*/
form * fv3 = dynamic_cast < formbtn * > (&form2);
/* compile succeeds bc form2 is derived from form 1 */
double dbl = static_cast<double> (25);
std::cout << dbl << "\n";
int i = static_cast<int> (2.3565);
std::cout << i << "\n";
}
/*
* simple template that accepts different ;
* types and returns a bool or the greatest of the two
*/
#include "stdafx.h"
#include <iostream>
using namespace std;
template <class B> bool isGreater(B a, B b)
{
return ( a >= b ? true : false);
};
template <class G> G Order(G a, G b)
{
return (a >= b ? a : b);
};
void main()
{
cout << isGreater(2, 1) << "\n";
cout << isGreater(1.343, 1.6) << "\n";
cout << isGreater('a', 'k') << "\n";
cout << Order('a', 'k') << "\n";
cout << Order(1, -1) << "\n";
getchar();
}
/*
* operator overloading ;
* redefining the float and int operators
*/
#include <iostream>
using namespace std;
class cfloat
{
private:
float fx;
public:
cfloat(float ifx)
{
fx = ifx;
};
/* if you just have one, it'll default to that */
operator float()
{
return fx + 1;
}
/* defining operators differently */
operator int()
{
return fx - 1;
}
};
int main()
{
cfloat x(0);
cout << " x now " << (float) x << "\n";
cout << " x after " << (int) x << "\n";
}
/* reference to a variable */
#include <iostream>
using namespace std;
void main()
{
int i = 0;
/*~~~~~~~~~~~*/
int & ir = i;
/*~~~~~~~~~~~*/
cout << " i before " << i << "\n";
ir++;
cout << " i after " << i << "\n";
}
/* overloading +,- operators to handle vectors */
#include <iostream>
using namespace std;
class vector
{
private:
double x, y;
public:
vector(double ix, double iy)
{
x = ix;
y = iy;
};
void print()
{
printf("%d,%d\n", x, y);
};
vector operator + (vector iv)
{
return vector(x + iv.x, y + iv.y);
};
vector operator - (vector iv)
{
return vector(x - iv.x, y - iv.y);
};
};
void main()
{
vector v1(1, 1);
v1.print();
vector v2(4, 4);
v2 vector v3 = v1 + v2;
v3.print();
}
copy with pointer increment
/*
* uses increment on a pointer to ;
* copy one string to another
*/
#include <iostream>
using namespace std;
void main()
{
void strcopy(char * in, char * out);
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
char * mystr = "This is my first string";
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
char mystr2[80];
strcopy(mystr, mystr2);
cout << mystr2 << endl;
}
void strcopy(char * in, char * out)
{
while (*in)
{
* (out++) = * (in++);
}
}
new and delete (using a destructor)
#include <iostream>
#include <cstring>
using namespace std;
class String
{
private:
char * str;
public:
String(char * s)
{
int len = strlen(s);
str = new char[len + 1];
strcpy(str, s);
};
char *
value()
{
return str;
};
~String()
{
cout << "destructing: " << endl;
delete [] str;
};
};
void main()
{
String mys = "This is a sample string that will be trimmed down to size";
cout << mys.value() << endl;
}
#include <iostream>
#include <string>
using namespace std;
class clsmybase{
protected:
string name;
public:
string getname() {return name;};
virtual float getdata() = 0;
virtual bool getenrolled() = 0;
};
class student: public clsmybase{
private:
float gpa;
bool enrolled;
public:
student(string name,float gpa,bool enrolled)
{clsmybase::name = name;
this->gpa=gpa;
this->enrolled=enrolled;};
float getdata(){return this->gpa;};
bool getenrolled(){return this->enrolled;};
};
class prof: public clsmybase{
private:
float salary;
bool tenured;
public:
prof(string name, float salary, bool tenured)
{
clsmybase::name = name;
this->salary = salary;
this->tenured = tenured;};
float getdata(){return this->salary;};
bool getenrolled(){return this->tenured;};
};
void Disp(clsmybase * s)
{
cout << s->getname() << " " << s->getdata() << " " << s->getenrolled()<< "\n";
}
void main(){
student * bob = new student("bobby",3.2F,true);
prof * bill = new prof("prof billy",100000.0F,true);
Disp(bob);
Disp(bill);
cin.get();
};
class vector1{
protected:
double x;
public:
vector1(double ix){x=ix;}
vector1(){x=0;};
void tostring(){
printf("(%f)\n",x);
};
};
class vector2: public vector1{
protected:
double y;
public:
vector2(double ix,double iy) : vector1(ix){y=iy;};
vector2():vector1(){y=0;};
void tostring(){
printf("(%f,%f)\n",x,y);
};
friend vector2 operator + (vector2 v1, vector2 v2){
return vector2 (v1.x + v2.x, v1.y + v2.y);
};
};
void main()
{
vector2 v2(-1,6);
vector2 v3(-3,8);
vector2 v1 = v2+v3;
v1.tostring();
};
/*
* program to allow entered data ;
* and sort it, using array of pointers
*/
#include <iostream>
#include <string>
using namespace std;
/* employee class */
class empl
{
private:
string name;
public:
/* constructor */
empl(string iname)
{
name = iname;
};
/* method for accessing private member, name */
string getname()
{
return name;
};
};
void main()
{
void bsort(empl ** pp, int n);
empl * emplptr[100];
int n = - 1;
string name;
do
{
n++;
cout << "Enter a name (quit to quit) " ;
cin >> name;
if (name != "quit")
{
emplptr[n] = new empl(name);
/*
* cout << emplptr[n]->getname();
*/
}
}
while(name != "quit");
n--;
cout << "Original List" << endl;
for (int j = 0; j <= n; j++)
{
cout << emplptr[j]->getname() << endl;
};
cout << "Sorted List" << endl;
bsort(emplptr, n);
for (int j = 0; j <= n; j++)
{
cout << emplptr[j]->getname() << endl;
};
cin.get();
cin.get();
};
void bsort(empl ** pp, int n)
{
void order(empl **, empl **);
for (int j = 0; j <= n; j++)
{
for (int k = j + 1; k <= n; k++)
{
order(pp + j, pp + k);
};
/* end k */
};
/* end j */
};
/*
=======================================================================================================================
pp1 and pp2 are pointers to arrays of empl ;
argument accepts pointers to pointer arrays
=======================================================================================================================
*/
void order(empl ** pp1, empl ** pp2)
{
/*
* use > as you would for numbers;
* * use -> for accessing members when using pointer
*/
if ((*pp1)->getname() > (*pp2)->getname())
{
/* pp1 is greater, thus, set a temp pointer to point to pp1 */
empl * tmpptr = * pp1;
/* set pp1 to point to pp2 (pp2 is smaller, therfore earlier in list */
*pp1 = * pp2;
/* set pp2 to point to temp */
*pp2 = tmpptr;
};
};
#include <iostream>
using namespace std;
class vector3
{
public:
double a,b,c;
vector3(double ia,double ib, double ic){a=ia;b=ib;c=ic;};
void tostring(){printf("(%f,%f,%f)\n",a,b,c);};
friend vector3 operator +(vector3 v1, vector3 v2)
{
return vector3(v1.a+v2.a,v1.b+v2.b,v1.c+v2.c);
};
};
template <class V> V sum(V &a, V &b)
{
return a + b;
};
void main()
{
vector3 v1(1,1,1);
vector3 v2(2,5,-1);
(v1+v2).tostring();
vector3 v3=sum(v1,v2);
v3.tostring();
}
binary i/o
#include <fstream>
#include <iostream>
using namespace std;
const int NUM = 26;
double buffer[NUM];
void main()
{
for(int j = 0; j < NUM; j++)
{
*(buffer + j) = (double) j;
};
ofstream buffout("buffer.dat", ios::binary);
buffout.write(reinterpret_cast < char * > (buffer), NUM * sizeof(double));
buffout.close();
cout << " File Written to " << endl;
for(int j = 0; j < NUM; j++)
{
*(buffer + j) = (double) 0;
};
ifstream buffin("buffer.dat", ios::binary);
buffin.read(reinterpret_cast < char * > (buffer), NUM * sizeof(double));
for(int j = 0; j < NUM; j++)
{
cout << j << "," << *(buffer + j) << endl;
if(*(buffer + j) != j)
{
cerr << "Wrong!";
};
};
cout << "Info read correctly" << endl;
cin.get();
};
};