C++ 'da basit bir sınıf nasıl yazılır?

Question

C++ sınıfında pek çok eğitici okuyorum ama diğer derslerin içerdiği bir şeyi özlüyorlar.

Birisi, görünürlük, yöntemler ve basit bir kurucu ve yıkıcı kullanan çok basit bir C++ sınıfının nasıl yazılacağını ve kullanılabildiğini gösterebilir mi?

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

Eh alınan örnek belgelenmiş ve Constructors and Destructors in C++ daha iyi açıkladı:

#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 ama, işte buradasın. "Görünürlük" ifadesinin bir yanlış isim olduğunu unutmayın: kamu ve özel kontrol erişilebilirliği, ancak "özel" öğeler bile dışarıdan "görünür" olsa bile, erişilebilir (bunu denemek ve erişmek için bir hatadır).

Answer 4

o, bu karmaşık bir iki tasarım paradigmaların bir kavşak hizmet ++ en az C C++ :)

Sınıfların yeni Ziyaretçi için o kadar kolay değil çünkü cevap denemeye değer

bir öğrenci, olsa bile

1) ADT :: temelde yeni bir tür, tamsayılar 'int' veya gerçek sayılar 'çift' gibi bir şey veya 'tarih' gibi yeni bir kavram anlamına gelir. Basit sınıf gibi görünmelidir bu durumda ,

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

bu bir ADT en temel iskeleti ... Tabii kamu alanı göz ardı ederek daha basit olabilir! ve erişim değiştiricilerini (genel, özel) siler ve her şey özel olacaktır. ama bu sadece saçmalık. NewDataType işe yaramaz hale geldiğinden! , yalnızca bildirebileceğiniz bir “int” hayal edin, ancak bununla hiçbir şey yapamazsınız. Daha sonra, NewDataType'ın varlığı için temel olarak gerekli olmayan bazı yararlı araçlara gereksiniminiz vardır, ancak bunları, türünüzün dildeki herhangi bir 'ilkel' türüne benzemesine izin vermek için bunları kullanırsınız. Üste |

Birincisi Oluşturucu. Kurucu, dilde birçok yerde gereklidir. int'ye bakın ve davranışını taklit etmeye çalışalım.

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. 

yukarıdaki hatlarının her satır

değişken orada oluşturulmuş olur, bir bildirimidir.

ve sonunda

burada derleyici istediğiniz herhangi bir şey söyleyebilir,

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

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

sihirli satır göreceksiniz, bir işlevde yukarıdaki int değişkenler, bu fonksiyon 'eğlenceli' denir düşünün! her şeyi yaptıktan sonra ve NewDataType öğeniz, işlevdeki yerel kapsam için artık daha yararlı olmaz, KILL IT. klasik bir örnek 'yeni' ile ayrılan hafızayı serbest bırakır!

yüzden bizim çok basit 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; 
}; 

Şimdi bu kamu işlevleri sağlamak için sahip yararlı bir sınıf oluşturmaya başlamak için, çok temel iskeleti, olur.

, minik araçlar LOT C++ bir sınıf inşa göz önünde bulundurulması gereken

vardır. . . . 2) Nesne: temelde yeni bir tür anlamına gelir, fakat fark, kardeşlere, kız kardeşlere, atalara ve torunlara ait olmasıdır. 'çift' ve 'int', C++ 'ye bakın,' int 'bir' double 'güneşidir, çünkü her' int 'en azından kavram olarak' double 'olur :)