C/C++ - [C++]Come includere una classe in un file .h ?

Salve,
dovrei creare un programma abbastanza grande e allora ho deciso di farlo orientato agli oggetti, ma ho un problema: praticamente voglio creare tanti file *.h quante sono le classi. Così le includerei nel main.cpp in modo da avere un main "più leggibile".
Io per adesso ho scritto questo codice:

main.cpp:

#include <iostream>
#include "prova.h"
using namespace std;
int main (){
    prv r;
    cin>>r.x;
    cin>>r.y;
    system("pause");
    return 0;
    }

prova.h:

class prv{
      public:
             int x, y;
             int somma(){
                 return x+y;
                 }
      }

ma non va...

Come si fa ad includere una classe in c++?
Grazie.

Ai dimenticato il ";" alla fine della dichiarazione della classe.

che errore del cavolo XD... Spesso sono i ; che creano i problemi più grandi di un programmatore...

e tu HAI dimenticato qualcos'altro XD

... di molto più importante....

La h!!! xD

mmm.. solitamente un header .h deve contenere solo prototipi o classi, il corpo delle funzioni o classi và contenuta in un altro file .cpp che solitamente ha lo stesso nome dell'header .h

quoto Lawliet.
La pratica di includere il codice dei metodi nell'header è comunemente usata nelle classi del Java e forse di altri linguaggi simili. In C++ si DEVE separare il prototipo (nell'header .h) dall'implementazione (nel codice .cpp).
Se non vengono separati, si ottiene una duplicazione del codice quanto includi lo stesso header in due diversi file del progetto con conseguente super cazziatone da parte del linker.
Nel tuo caso, cioè un unico file di codice (il famigerato main.cpp) il problema non si nota, ma scrivendo un programma "vero" (con almeno qualche decina di sorgenti) ti troveresti nel costante incubo dell'organizzazione degli headers.

E' buona norma, quindi, fare in questo modo:

prima si creano i prototipi della classe

// MiaClasse.h

// questo #pragma indica al compilatore di non duplicare questa inclusione, per evitare ridefinizioni fastidiose
#pragma once

class MiaClasse
{
public:
  MiaClasse(); // Costruttore
  ~MiaClasse(); // Distruttore

  int GetChupaCabra();  // Un metodo getter qualsiasi
  void SetChupaCabra(int value); // Un metodo setter qualsiasi

private:
  int m_chupaCabra;  // Una variabile privata
};

poi si crea l'implementazione della classe su un file separato:

// MiaClasse.cpp
// Richiamo i prototipi definiti nell'header e li implemento
#include "MiaClasse.h"

// Il costruttore...
MiaClasse::MiaClasse()
{
  m_chupaCabra = 0;
}

// ... e suo cugino
MiaClasse::~MiaClasse()
{
  // non faccio nulla
}

// I metodi get e set per la variabile privata (questo si chiama "incapsulamento" ragazzo!)
void MiaClasse::SetChupaCabra(int value)
{
  m_chupaCabra = value;
}

int MiaClasse::GetChupaCabra()
{
  return m_chupaCabra;
}

e infine si utilizza la classe nel file in cui serve, supponiamo il main.cpp

#include <iostream>

// includo la classe
#include "MiaClasse.h"

using namespace std;

int main(int argc, char **argv)
{
  MiaClasse kane, zotico;

  kane.SetChupaCabra(400);
  zotico.SetChupaCabra(300);
  
  cout << "Kane ha " << kane.GetChupaCabra() << " capre morte" << endl;
  cout << "lo zotico ha " << zotico.GetChupaCabra() << " capre morte" << endl;

  return 0;
}

In questo caso non uso new e delete in quanto alloco la classe nello stack, quindi il distruttore verrà chiamato subito prima dell'uscita dello scope di visibilità della stessa variabile (in questo caso alla fine del main).

Infine bisogna compilare entrambi i file .cpp, e linkarli insieme. Se usi visual studio no problem. Se usi GCC "liscio" usa la sintassi:

gcc -o cabron.bin MiaClasse.cpp main.cpp

ed esegui usando il comando ./cabron.bin

Buon divertimento!

PS: Ah, dimenticavo. Ho scritto il codice senza provarlo sul compilatore, quindi c'è un'elevata probabilità che abbia fatto qualche errore... testare per credere!