Where do things go?
Now that we know how to define a class, and how to implement its methods, lets look at where things go.
Note: These things are conventions in real life, but for me (and that means for you in this class) they are unbreakable rules!
Rules:
- The class defintion belongs in a header file (.h), that has the exact same name and capitalization of the class. Example: Hello.h 
- The class implementation belongs in a source file (.cpp) that has the exact same name and capitalization of the class. Example: Hello.cpp 
- The header file will be guared against multiple inclusion with the #ifndef ... #define .. #endif construct 
- The source file will always include its own class definition (e.g. #include "Hello.h" ) 
This way, there are always 2 files for each class (exception: pure virtual classes).
Note: If you use eclipse you can have ecplise create these files for you (say New / Class)
To start the program, we still need a main() function. This function should go into its own file, preferably something like "main.cpp". In good OO programs this function is very short! Example:
#include "SomeClass.h"
int main() 
{
  SomeClass *myInstance = new SomeClass();
  myInstance->start();
  delete myInstance;
  return 0;
}
Remember to always include things where there are used!
Because I love graphics, here's another graphic showing the same thing:
But enough theory, here is a complete example:
#ifndef HELLO_H_
#define HELLO_H_
class Hello
{
private:
  bool formal;
public:
  void greeting();
  void setFormal(bool f);
  bool getFormal();
};
#endif /*HELLO_H_*/
#include "Hello.h"
#include <iostream>
using namespace std;
void Hello::greeting()
{
  if (formal)
    cout << "Hello, nice to meet you!" << endl;
  else 
    cout << "What's up?" << endl;
}
void Hello::setFormal(bool f)
{
  formal = f;
}
bool Hello::getFormal()
{
  return formal;
}#include "Hello.h"
int main()
{
  Hello *h = new Hello();
  h->setFormal(true);
  h->greeting();
  delete h;
  return 0;
}