Как написать простой класс в C++?

Question

Я читал много учебников по классу C++, но они пропускают то, что включает в себя другие учебные пособия.

Может кто-нибудь, пожалуйста, покажите мне, как писать и использовать очень простой класс C++, который использует видимость, методы и простой конструктор и деструктор?

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

Хорошо документированный пример, взятый и объяснил, лучше из 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; 
} 

Глупо, но вы есть. Обратите внимание, что «видимость» является неправильным: доступность для публичного и частного контроля, но даже «частные» вещи по-прежнему «видны» снаружи, а не доступны (это ошибка, чтобы попытаться получить к нему доступ).

Answer 4

Даже если он студент, стоит попытаться ответить, потому что это сложный один не так просто, по крайней мере для нового Посетительница C++ :)

классов в C++ служит пересечение двух конструктивных парадигм,

1) ADT :: что означает принципиально новый тип, что-то вроде целых чисел 'int' или реальных чисел 'double' или даже новая концепция, подобная 'date'. в этом случае простой класс должен выглядеть так,

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

это самый основной скелет ADT ... , конечно, это может быть проще, не обращая внимания на публичных местах! и стирание модификаторов доступа (общедоступных, частных), и все это будет частным. но это просто вздор. Потому что NewDataType становится бесполезным! Представьте себе «int», который вы можете просто объявить, но вы НЕ МОЖЕШЬ с ним что-либо делать.

Затем вам нужны полезные инструменты, которые в основном не требуются для существования типа NewDataType, но вы используете их, чтобы ваш тип выглядел как «примитивный» тип на языке.

Первый конструктор. Конструктор необходим во многих местах на этом языке. Посмотрите на int и попытайтесь подражать его поведению.

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. 

Каждая строка вышеуказанных строк является декларацией, здесь строится переменная.

и в конце концов представьте выше ИНТ переменные в функции, эта функция называется «удовольствием»,

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

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

вы видите волшебную линию, здесь вы можете сказать компилятор любой вещи вы хотите! после того, как вы сделаете все, и ваш NewDataType не более полезен для локальной области видимости, как в функции, вы УБИРАЕТЕ ЭТО. классический пример будет освобождать память, зарезервированную «новым»!

поэтому наш очень простой NewDataType становится,

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

Сейчас это очень простой скелет, чтобы начать строить полезный класс, вы должны предоставить государственные функции.

Есть много крошечных инструментов, чтобы рассмотреть в создании класса в C++,

. . . .

2) Объект :: что означает принципиально новый тип, но разница в том, что он принадлежит братьям, сестрам, предкам и потомкам. посмотрите на «double» и «int» на C++, «int» - это солнце «double», потому что каждый «int» является «двойным», по крайней мере, в концепции :)