web-dev-qa-db-fra.com

Comment écrire une classe simple en C ++?

J'ai lu beaucoup de tutoriels sur la classe C++ mais ils manquent quelque chose que d'autres tutoriels incluent.

Quelqu'un peut-il me montrer comment écrire et utiliser une classe C++ très simple qui utilise la visibilité, des méthodes et un simple constructeur et destructeur?

c++constructordestructorpublicprivate-members
42
Babiker

Exemple bien documenté pris et mieux expliqué de Constructeurs et destructeurs en 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;
}
32
TStamper

Même s'il est étudiant, cela vaut la peine d'essayer de répondre car il est complexe pas si simple du moins pour un nouveau Visiteur de C++ :)

Les classes en C++ servent une intersection de deux paradigmes de conception,

1) ADT :: qui signifie fondamentalement un nouveau type, quelque chose comme des entiers 'int' ou des nombres réels 'double' ou même un nouveau concept comme 'date'. dans ce cas, la classe simple devrait ressembler à ceci,

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

c'est le squelette le plus basique d'un ADT ... bien sûr, il peut être plus simple en ignorant l'espace public! et l'effacement des modificateurs d'accès (public, privé) et le tout sera privé. mais c'est juste un non-sens. Parce que le NewDataType devient inutile! imaginez un "int" que vous pouvez simplement déclarer, mais vous NE POUVEZ rien faire avec.

Ensuite, vous avez besoin d'outils utiles qui ne sont fondamentalement pas nécessaires à l'existence du NewDataType, mais vous les utilisez pour laisser votre type ressembler à n'importe quel type "primitif" dans le langage.

le premier est le constructeur. Le constructeur est nécessaire à de nombreux endroits de la langue. regardez int et essayons d'imiter son comportement.

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.

chaque ligne des lignes ci-dessus est une déclaration, la variable y est construite.

et à la fin imaginez les variables int ci-dessus dans une fonction, cette fonction est appelée "fun",

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

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

vous voyez la ligne magique, ici vous pouvez dire au compilateur tout ce que vous voulez! une fois que vous avez fait tout et que votre NewDataType n'est plus utile pour la portée locale comme dans la fonction, vous le TUER. un exemple classique serait de libérer la mémoire réservée par "nouveau"!

donc notre très simple NewDataType devient,

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

Maintenant, c'est le squelette très basique, pour commencer à construire une classe utile, vous devez fournir des fonctions publiques.

il y a BEAUCOUP de petits outils à considérer dans la construction d'une classe en C++,

. . . .

2) Object :: qui signifie fondamentalement un nouveau type, mais la différence est qu'il appartient aux frères, sœurs, ancêtres et descendants. regardez 'double' et 'int' en C++, le 'int' est un soleil de 'double' parce que chaque 'int' est un 'double' au moins dans le concept :)

13
AraK
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() {}
};
10
1800 INFORMATION
#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;
}

Idiot, mais vous y êtes. Notez que "visibilité" est un terme impropre: accessibilité des contrôles publics et privés, mais même les choses "privées" sont toujours "visibles" de l'extérieur, tout simplement pas accessible (c'est une erreur d'essayer d'y accéder) .

8
Alex Martelli