Wie schreibe ich eine einfache Klasse in C++?

Question

Ich habe viele Tutorials zur C++ - Klasse gelesen, aber sie vermissen etwas, was andere Tutorials beinhalten.

Kann mir bitte jemand zeigen, wie man eine sehr einfache C++ - Klasse schreibt und verwendet, die Sichtbarkeit, Methoden und einen einfachen Konstruktor und Destruktor verwendet?

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

dokumentiert Nun Beispiel genommen und erklärt besser aus 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; 
} 

Albern, aber gibt es Sie. Beachten Sie, dass "Sichtbarkeit" eine falsche Bezeichnung ist: öffentliche und private Kontrolle Zugänglichkeit, aber auch "private" Zeug ist immer noch "sichtbar" von außen, nur nicht zugänglich (es ist ein Fehler zu versuchen und darauf zuzugreifen).

Answer 4

Auch wenn er ein Student, einen Versuch wert zu beantworten, weil es sehr komplex ist nicht so einfach, zumindest für einen neuen Besucher von C++ :)

Klassen in C++ eine Kreuzung von zwei Design-Paradigmen zu dienen,

1) ADT :: was bedeutet im Grunde ein neuer Typ, etwas wie ganze Zahlen 'int' oder reelle Zahlen 'doppelt' oder sogar ein neues Konzept wie 'Datum'. in diesem Fall die einfache Klasse wie folgt aussehen sollte,

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. 
. 
. 
. 
}; 

dies das Grundgerüst eines ADT ist ... natürlich kann es einfacher sein, durch den öffentlichen Bereich zu ignorieren! und löschen Sie die Zugriffsmodifikatoren (öffentlich, privat) und das Ganze wird privat sein. aber das ist nur Unsinn. Weil der NewDataType nutzlos wird! Stellen Sie sich ein 'int' vor, das Sie einfach deklarieren können, aber Sie können nichts damit machen.

Dann benötigen Sie einige nützliche Werkzeuge, die für die Existenz des NewDataType grundsätzlich nicht erforderlich sind, aber Sie verwenden sie, um Ihren Typ wie einen beliebigen "primitiven" Typ in der Sprache aussehen zu lassen.

der erste ist der Konstruktor. Der Konstruktor wird an vielen Stellen in der Sprache benötigt. schauen Sie sich int an und versuchen Sie, sein Verhalten zu imitieren.

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. 

Jede Zeile der obigen Zeilen ist eine Deklaration, die Variable wird dort konstruiert.

und am Ende vorstellen, dass die oben int Variablen in einer Funktion, die Funktion ‚Spaß‘ genannt wird,

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

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

Sie die magische Linie zu sehen, hier gibt es die Compiler sagen kann jeder, was Sie wollen! nachdem Sie alles tun und Ihr NewDataType ist nicht mehr nützlich für den lokalen Bereich wie in der Funktion, Sie KILL IT. ein klassisches Beispiel wäre die Freigabe des reservierten Speichers durch 'neu'!

so unsere sehr einfach NewDataType wird,

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; 
}; 

Nun ist diese die sehr Grundgerüst ist, den Aufbau einer nützlichen Klasse, die Sie öffentliche Funktionen zur Verfügung stellen müssen zu starten.

Es gibt eine Menge von kleinen Werkzeugen für den Aufbau einer Klasse in C++,

zu betrachten. . . .

2) Objekt :: was bedeutet im Grunde eine neue Art, aber der Unterschied ist, dass es zu Brüdern, Schwestern, Vorfahren und Nachkommen gehört. schau dir 'double' und 'int' in C++ an, das 'int' ist eine Sonne von 'double', weil jedes 'int' zumindest im Konzept 'double' ist :)