Come scrivere una semplice classe in C++?

Question

Ho letto un sacco di tutorial sulla classe C++ ma mancano qualcosa che includono altri tutorial.

Qualcuno può mostrarmi come scrivere e utilizzare una classe C++ molto semplice che utilizza visibilità, metodi e un semplice costruttore e distruttore?

Answer 1

class A 
{ 
    public: 
    // a simple constructor, anyone can see this 
    A() {} 
    protected: 
    // a simple destructor. This class can only be deleted by objects that are derived from this class 
    // probably also you will be unable to allocate an instance of this on the stack 
    // the destructor is virtual, so this class is OK to be used as a base class 
    virtual ~A() {} 
    private: 
    // a function that cannot be seen by anything outside this class 
    void foo() {} 
}; 

Answer 2

ben documentato esempio tratto e spiegato meglio da Constructors and Destructors in C++:

#include <iostream>   // for cout and cin 

class Cat      // begin declaration of the class 
{ 
    public:      // begin public section 
    Cat(int initialAge);  // constructor 
    Cat(const Cat& copy_from); //copy constructor 
    Cat& operator=(const Cat& copy_from); //copy assignment 
    ~Cat();     // destructor 

    int GetAge() const;  // accessor function 
    void SetAge(int age);  // accessor function 
    void Meow(); 
private:      // begin private section 
    int itsAge;    // member variable 
    char * string; 
}; 

// constructor of Cat, 
Cat::Cat(int initialAge) 
{ 
    itsAge = initialAge; 
    string = new char[10](); 
} 

//copy constructor for making a new copy of a Cat 
Cat::Cat(const Cat& copy_from) { 
    itsAge = copy_from.itsAge; 
    string = new char[10](); 
    std::copy(copy_from.string+0, copy_from.string+10, string); 
} 

//copy assignment for assigning a value from one Cat to another 
Cat& Cat::operator=(const Cat& copy_from) { 
    itsAge = copy_from.itsAge; 
    std::copy(copy_from.string+0, copy_from.string+10, string); 
} 

// destructor, just an example 
Cat::~Cat() 
{ 
    delete[] string; 
} 

// GetAge, Public accessor function 
// returns value of itsAge member 
int Cat::GetAge() const 
{ 
    return itsAge; 
} 

// Definition of SetAge, public 
// accessor function 
void Cat::SetAge(int age) 
{ 
    // set member variable its age to 
    // value passed in by parameter age 
    itsAge = age; 
} 

// definition of Meow method 
// returns: void 
// parameters: None 
// action: Prints "meow" to screen 
void Cat::Meow() 
{ 
    cout << "Meow.\n"; 
} 

// create a cat, set its age, have it 
// meow, tell us its age, then meow again. 
int main() 
{ 
    int Age; 
    cout<<"How old is Frisky? "; 
    cin>>Age; 
    Cat Frisky(Age); 
    Frisky.Meow(); 
    cout << "Frisky is a cat who is " ; 
    cout << Frisky.GetAge() << " years old.\n"; 
    Frisky.Meow(); 
    Age++; 
    Frisky.SetAge(Age); 
    cout << "Now Frisky is " ; 
    cout << Frisky.GetAge() << " years old.\n"; 
    return 0; 
} 

Answer 3

#include <iostream> 
#include <string> 

class Simple { 
public: 
    Simple(const std::string& name); 
    void greet(); 
    ~Simple(); 
private: 
    std::string name; 
}; 

Simple::Simple(const std::string& name): name(name) { 
    std::cout << "hello " << name << "!" << std::endl; 
} 

void Simple::greet() { 
    std::cout << "hi there " << name << "!" << std::endl; 
} 

Simple::~Simple() { 
    std::cout << "goodbye " << name << "!" << std::endl; 
} 

int main() 
{ 
    Simple ton("Joe"); 
    ton.greet(); 
    return 0; 
} 

Silly, ma, ci siete. Nota che "visibilità" è un termine improprio: l'accessibilità al controllo pubblico e privato, ma anche le cose "private" sono ancora "visibili" dall'esterno, solo accessibile (è un errore provarlo e accedervi).

Answer 4

Anche se lui è uno studente, vale la pena provare a rispondere, perché si tratta di un complesso non così facile, almeno per un nuovo visitatore di C++ :)

classi in C++ servire un incrocio di due paradigmi di progettazione,

1) ADT :: che significa fondamentalmente un nuovo tipo, qualcosa come numeri interi int 'o numeri reali' double 'o anche un nuovo concetto come' date '. in questo caso la semplice classe dovrebbe essere simile,

class NewDataType 
{ 
public: 
// public area. visible to the 'user' of the new data type. 
. 
. 
. 
private: 
// no one can see anything in this area except you. 
. 
. 
. 
}; 

questo è lo scheletro di base di un ADT ... Naturalmente può essere più semplice ignorando l'area pubblica! e cancellando i modificatori di accesso (pubblico, privato) e l'intera cosa sarà privata. ma non ha senso. Perché il NewDataType diventa inutile! Immagina un 'int' che puoi solo dichiarare ma NON PUOI fare nulla con esso.

Quindi, sono necessari alcuni strumenti utili che non sono fondamentalmente necessari all'esistenza di NewDataType, ma li si utilizza per consentire al tipo di apparire come qualsiasi tipo 'primitivo' nella lingua.

il primo è il Costruttore. Il costruttore è necessario in molti posti nella lingua. guarda int e proviamo a imitarne il comportamento.

int x; // default constructor. 

int y = 5; // copy constructor from a 'literal' or a 'constant value' in simple wrods. 
int z = y; // copy constructor. from anther variable, with or without the sametype. 
int n(z); // ALMOST EXACTLY THE SAME AS THE ABOVE ONE, it isredundant for 'primitive' types, but really needed for the NewDataType. 

ogni riga delle righe precedenti è una dichiarazione, la variabile viene costruita lì.

e alla fine immaginare le variabili int di cui sopra in una funzione, quella funzione si chiama 'fun',

int fun() 
{ 
    int y = 5; 
    int z = y; 
    int m(z); 

    return (m + z + y) 
    // the magical line. 
} 

si vede la linea magica, qui si può dire al compilatore qualsiasi cosa che si desidera! dopo aver fatto ogni cosa e il tuo NewDataType non è più utile per l'ambito locale come nella funzione, lo uccidi. un esempio classico sarebbe il rilascio della memoria riservata da 'nuovo'!

quindi il nostro semplice NewDataType diventa,

class NewDataType 
{ 
public: 
// public area. visible to the 'user' of the new data type. 
    NewDataType() 
    { 
     myValue = new int; 
     *myValue = 0; 
    } 

    NewDataType(int newValue) 
    { 
     myValue = new int; 
     *myValue = newValue; 
    } 

    NewDataType(const NewDataType& newValue){ 

     myValue = new int; 
     *myValue = newValue.(*myValue); 
    } 
private: 
// no one can see anything in this area except you. 
    int* myValue; 
}; 

Ora, questo è lo scheletro molto semplice, per iniziare a costruire una classe utile è necessario fornire funzioni pubbliche.

ci sono un sacco di piccoli strumenti da considerare nella costruzione di una classe in C++,

. . . .

2) Oggetto :: che in pratica significa un nuovo tipo, ma la differenza è che appartiene a fratelli, sorelle, antenati e discendenti. guarda 'double' e 'int' in C++, 'int' è un sole di 'double' perché ogni 'int' è un 'doppio' almeno nel concetto :)