सी ++ में एक साधारण कक्षा कैसे लिखें?

Question

मैं सी ++ कक्षा पर बहुत सारे ट्यूटोरियल पढ़ रहा हूं लेकिन उन्हें कुछ अन्य ट्यूटोरियल शामिल हैं।

क्या कोई मुझे दिखा सकता है कि एक बहुत ही सरल सी ++ कक्षा लिखने और उपयोग करने के लिए जो दृश्यता, विधियों और सरल निर्माता और विनाशक का उपयोग करता है?

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

यहां तक ​​कि अगर वह एक छात्र,,

जवाब देने के लिए है, क्योंकि यह एक परिसर में एक कम से कम सी में सी ++ :)

वर्गों का एक नया आगंतुक के लिए है कि आसान नहीं है दो डिजाइन मानदंड के एक चौराहे की सेवा ++ कोशिश कर रहा लायक है

1) एडीटी :: जिसका अर्थ है मूल रूप से एक नया प्रकार, पूर्णांक 'int' या वास्तविक संख्या 'डबल' या यहां तक ​​कि 'डेट' जैसी नई अवधारणा। इस मामले साधारण क्लास इस तरह दिखना चाहिए में ,

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

यह है एक एडीटी का सबसे बुनियादी कंकाल ... निश्चित रूप से यह सार्वजनिक क्षेत्र की अनदेखी करके सरल हो सकता है! और एक्सेस संशोधक मिटाएं (सार्वजनिक, निजी) और पूरी चीज निजी होगी। लेकिन यह सिर्फ बकवास है। क्योंकि न्यूडाटा टाइप बेकार हो जाता है! एक 'int' की कल्पना करें जिसे आप अभी घोषित कर सकते हैं लेकिन आप इसके साथ कुछ भी नहीं कर सकते हैं।

फिर, आपको कुछ उपयोगी टूल की आवश्यकता है जो मूल रूप से न्यूडाटा टाइप के अस्तित्व के लिए आवश्यक नहीं हैं, लेकिन आप उनका उपयोग भाषा में किसी भी 'आदिम' प्रकार की तरह दिखने के लिए करते हैं।

पहला वाला कन्स्ट्रक्टर है। भाषा में कई स्थानों पर निर्माता की आवश्यकता है। 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 हो जाता है,

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

अब इस आप सार्वजनिक कार्यों प्रदान करने के लिए एक उपयोगी वर्ग का निर्माण शुरू करने के लिए बहुत बुनियादी कंकाल है।

वहाँ,

छोटे उपकरणों की एक बहुत सी ++ में एक वर्ग के निर्माण में विचार करने के लिए कर रहे हैं। । । ।

2) ऑब्जेक्ट :: जिसका मूल रूप से एक नया प्रकार है, लेकिन अंतर यह है कि यह भाइयों, बहनों, पूर्वजों और वंशजों से संबंधित है। सी ++ में 'डबल' और 'int' को देखें, 'int' 'डबल' का सूर्य है क्योंकि प्रत्येक 'int' कम से कम अवधारणा में 'डबल' है :)