¿Cómo escribir una clase simple en C++?

Question

He estado leyendo una gran cantidad de tutoriales en la clase C++ pero se pierden algo que otros tutoriales incluyen.

¿Puede alguien mostrarme cómo escribir y utilizar una clase de C++ muy simple que utiliza visibilidad, métodos y un simple constructor y destructor?

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

Bueno ejemplo tomado documentado y explicado mejor a partir de 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; 
} 

tonto, pero, ahí estás. Tenga en cuenta que "visibilidad" es un nombre inapropiado: acceso de control público y privado, pero incluso las cosas "privadas" todavía son "visibles" desde afuera, simplemente no es accesible (es un error intentar acceder).

Answer 4

Incluso si es un estudiante, vale la pena tratar de responder, ya que es un problema complejo no es tan fácil, al menos para un nuevo Visitador de C++ :)

Clases en C++ servir a una intersección de dos paradigmas de diseño,

1) ADT :: que significa básicamente un nuevo tipo, algo así como enteros 'int' o números reales 'doble' o incluso un nuevo concepto como 'fecha'. en este caso la clase simple debe tener este aspecto,

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

este es el esqueleto más básica de un ADT ... por supuesto puede ser más simple, ignorando el área pública! y borrar los modificadores de acceso (público, privado) y todo será privado. pero eso no tiene sentido. ¡Porque NewDataType se vuelve inútil! imagine un 'int' que puede declarar pero NO PUEDE hacer nada con él.

Luego, necesita algunas herramientas útiles que básicamente no son necesarias para la existencia de NewDataType, pero las usa para que su tipo se parezca a cualquier tipo 'primitivo' en el idioma.

el primero es el Constructor. El constructor es necesario en muchos lugares del idioma. mira int y vamos a tratar de imitar su comportamiento.

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. 

cada línea de las líneas anteriores es una declaración, la variable se construye allí.

y al final se imaginan las variables int anteriores en una función, esa función se llama 'diversión',

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

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

que ver la línea mágica, aquí se puede indicar al compilador cualquier cosa que usted quiere! después de hacer cada cosa y su NewDataType no es más útil para el ámbito local como en la función, KILL IT. ¡un ejemplo clásico sería liberar la memoria reservada por 'nuevo'!

por lo que nuestro NewDataType muy simple se convierte,

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

Ahora bien, este es el esqueleto muy básico, para empezar a construir una clase útil tiene que proporcionar las funciones públicas.

hay una gran cantidad de pequeñas herramientas a tener en cuenta en la construcción de una clase en C++,

. . . .

2) Objeto :: lo que significa básicamente un nuevo tipo, pero la diferencia es que pertenece a hermanos, hermanas, ancestros y descendientes. mira 'doble' e 'int' en C++, 'int' es un sol de 'doble' porque cada 'int' es 'doble' al menos en concepto :)