Làm thế nào để viết một lớp đơn giản trong C++?

Question

Tôi đã đọc rất nhiều bài hướng dẫn về lớp C++ nhưng họ bỏ lỡ điều gì đó mà các hướng dẫn khác bao gồm.

Có thể ai đó vui lòng chỉ cho tôi cách viết và sử dụng lớp C++ rất đơn giản có sử dụng khả năng hiển thị, phương thức và hàm tạo đơn giản và phá hủy không?

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

Vâng tài liệu ví dụ thực hiện và giải thích tốt hơn từ 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; 
} 

Silly, nhưng, có bạn đang có. Lưu ý rằng "khả năng hiển thị" là từ sai: khả năng truy cập công khai và riêng tư, nhưng ngay cả nội dung "riêng tư" vẫn "hiển thị" từ bên ngoài, chỉ cần không có thể truy cập (đó là lỗi để thử và truy cập).

Answer 4

Thậm chí nếu anh ấy là một sinh viên, giá trị cố gắng để trả lời bởi vì nó là một trong những phức tạp không phải là dễ dàng ít nhất là cho một lượt truy cập mới của C++ :)

Lớp học trong C++ phục vụ một giao điểm của hai mô hình thiết kế,

1) ADT :: có nghĩa là về cơ bản một kiểu mới, giống như số nguyên 'int' hoặc số thực 'tăng gấp đôi' hoặc thậm chí một khái niệm mới như 'ngày'. trong trường hợp này lớp đơn giản nên trông như thế này,

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

đây là bộ xương cơ bản nhất của một ADT ... tất nhiên nó có thể được đơn giản hơn bằng cách bỏ qua các khu vực công cộng! và xóa các công cụ sửa đổi truy cập (công khai, riêng tư) và toàn bộ nội dung sẽ là riêng tư. nhưng đó chỉ là vô nghĩa. Bởi vì NewDataType trở nên vô dụng! hãy tưởng tượng một 'int' mà bạn chỉ có thể khai báo nhưng bạn KHÔNG THỂ làm bất cứ điều gì với nó.

Sau đó, bạn cần một số công cụ hữu ích về cơ bản không cần thiết cho sự tồn tại của NewDataType, nhưng bạn sử dụng chúng để cho kiểu của bạn trông giống như kiểu 'nguyên thủy' trong ngôn ngữ.

đầu tiên là Constructor. Các nhà xây dựng là cần thiết ở nhiều nơi trong ngôn ngữ. xem int và cho phép thử bắt chước hành vi của nó.

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. 

mỗi dòng của các dòng trên là tuyên bố, biến được tạo ở đó.

và cuối cùng tưởng tượng int biến trên trong một hàm, chức năng đó được gọi là 'vui vẻ',

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

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

bạn nhìn thấy dòng kỳ diệu, ở đây bạn có thể nói với trình biên dịch bất cứ điều gì bạn muốn! sau khi bạn làm mọi điều và NewDataType của bạn không hữu ích hơn cho phạm vi địa phương như trong hàm, bạn KILL IT. một ví dụ cổ điển sẽ giải phóng bộ nhớ được dành riêng cho 'mới'!

nên NewDataType rất đơn giản của chúng tôi sẽ trở thành,

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

Bây giờ đây là bộ xương rất cơ bản, để bắt đầu xây dựng một lớp học hữu ích bạn phải cung cấp các chức năng công cộng.

có rất nhiều công cụ nhỏ để xem xét trong việc xây dựng một lớp học trong C++,

. . . .

2) Đối tượng :: có nghĩa là về cơ bản một loại mới, nhưng sự khác biệt là nó thuộc về anh em, chị em, tổ tiên và hậu duệ. nhìn vào 'đôi' và 'int' trong C++, 'int' là mặt trời của 'đôi' vì mỗi 'int' là 'đôi' ít nhất là trong khái niệm :)