Lớp trong C++: định nghĩa đối tượng, thành viên và phương thức

Lớp là gì

Lớp (class) là bản thiết kế cho một kiểu tự định nghĩa, gom dữ liệu (biến thành viên) và hành vi (hàm thành viên) vào một khối. Các kiểu có sẵn như int và double mô tả những giá trị đơn lẻ, còn lớp cho phép bạn mô hình hóa cả một khái niệm, như một tài khoản ngân hàng, một điểm 2D hay một người chơi, thành một giá trị duy nhất mà bạn truyền đi được.

Bạn đã dùng lớp mà chưa cần tự định nghĩa: std::string và container vector đều là lớp trong thư viện chuẩn. Gọi name.length() hay v.push_back(3) chính là gọi một hàm thành viên trên một đối tượng. Giờ bạn sẽ xây dựng các kiểu của riêng mình theo cùng cách đó, rồi chuyển sang hàm khởi tạo để khởi tạo chúng.

Định nghĩa lớp và tạo đối tượng

Định nghĩa lớp liệt kê các thành viên trong cặp ngoặc nhọn và kết thúc bằng dấu chấm phẩy; quên dấu ; ở cuối là một trong những lỗi phổ biến nhất của người mới. Mỗi đối tượng bạn tạo từ lớp có bản sao biến thành viên của riêng nó.

#include <iostream>
#include <string>
using namespace std;

class Dog {
public:
    string name;   // member variable
    int age;       // member variable

    void bark() {  // member function
        cout << name << " says woof!" << endl;
    }
};

int main() {
    Dog rex;            // create an object (instance)
    rex.name = "Rex";   // set members with the . operator
    rex.age = 4;

    Dog luna;           // a second, independent object
    luna.name = "Luna";

    rex.bark();
    luna.bark();
    return 0;
}

rex và luna là hai đối tượng riêng biệt. Thay đổi rex.name không ảnh hưởng tới luna.name: mỗi đối tượng giữ dữ liệu của riêng mình. Bạn truy cập thành viên bằng toán tử chấm . trên một đối tượng (hoặc -> khi bạn có con trỏ tới nó).

public và private

Mặc định, mọi thứ trong class đều là private: chỉ các hàm thành viên của chính lớp đó mới chạm được vào. Nhãn public: mở các thành viên ra cho code bên ngoài. Sự phân chia này là cốt lõi của tính đóng gói: bạn để lộ một giao diện an toàn và giấu dữ liệu bên trong để nó không thể rơi vào trạng thái không hợp lệ.

#include <iostream>
using namespace std;

class Counter {
private:
    int count = 0;            // hidden - outsiders can't touch it

public:
    void increment() {        // the safe interface
        count++;
    }
    int value() const {       // const: this function won't modify the object
        return count;
    }
};

int main() {
    Counter c;
    c.increment();
    c.increment();
    cout << "Count: " << c.value() << endl;

    // c.count = 100;   // ERROR: 'count' is private
    return 0;
}

Vì count là private, không nơi gọi nào có thể lén đưa vào một giá trị âm hay vô nghĩa: họ phải đi qua increment(). Từ const sau danh sách tham số của value() hứa rằng hàm sẽ không sửa đổi đối tượng, cho phép bạn gọi nó trên các đối tượng const và cho người đọc thấy rõ ý định.

Khai báo và định nghĩa phương thức

Với lớp nhỏ, định nghĩa phương thức ngay trong lớp (như trên) là ổn. Với lớp lớn hơn, người ta thường khai báo phương thức bên trong lớp và định nghĩa phần thân bên ngoài, dùng cú pháp phạm vi ClassName::method. Cách này giữ cho định nghĩa lớp dễ đọc như một bản tóm tắt giao diện.

#include <iostream>
#include <string>
using namespace std;

class Rectangle {
public:
    double width;
    double height;

    double area() const;        // declaration only
    void describe() const;      // declaration only
};

// Definitions live outside, qualified with Rectangle::
double Rectangle::area() const {
    return width * height;
}

void Rectangle::describe() const {
    cout << width << " x " << height
         << " = " << area() << endl;   // can call other members directly
}

int main() {
    Rectangle r;
    r.width = 3.0;
    r.height = 4.0;
    r.describe();
    return 0;
}

Tiền tố Rectangle:: cho trình biên dịch biết hàm thuộc về lớp nào. Bên trong định nghĩa như vậy, bạn vẫn gọi thành viên bằng tên trần (width, area()): trình biên dịch biết chúng thuộc về đối tượng mà phương thức được gọi trên đó.

Con trỏ this

Bên trong mọi hàm thành viên không static, this là con trỏ trỏ tới đối tượng mà hàm được gọi trên đó. Thường bạn không cần nó, vì tên thành viên trần đã chỉ tới đối tượng hiện tại. Nó phát huy tác dụng khi một tham số che khuất một thành viên, tức hai cái trùng tên, và bạn phải phân biệt chúng.

#include <iostream>
using namespace std;

class Point {
public:
    int x = 0;
    int y = 0;

    void setX(int x) {     // parameter 'x' shadows member 'x'
        this->x = x;       // this->x is the member; x is the parameter
    }

    void print() const {
        cout << "(" << x << ", " << y << ")" << endl;
    }
};

int main() {
    Point p;
    p.setX(7);
    p.print();
    return 0;
}

Không có this->, viết x = x; bên trong setX sẽ gán tham số cho chính nó và để nguyên thành viên: một bug âm thầm. this->x làm mọi thứ rõ ràng. Nhiều codebase tránh hẳn vấn đề này bằng cách đặt tên tham số khác đi (ví dụ setX(int newX)), nhưng bạn vẫn sẽ thấy this-> liên tục trong code thực tế.

Lỗi thường gặp

Một vài cái bẫy về lớp khiến người học vấp đi vấp lại:

• Thiếu dấu chấm phẩy ở cuối. Định nghĩa lớp kết thúc bằng };. Bỏ dấu ; và bạn sẽ nhận một loạt lỗi khó hiểu chỉ vào những gì nằm sau lớp, chứ không phải chính lớp đó.
• Quên khởi tạo thành viên. Các thành viên kiểu có sẵn như int và double không tự động được gán bằng 0. Đọc một thành viên chưa khởi tạo là undefined behavior. Hãy cho thành viên giá trị mặc định (int count = 0;) hoặc khởi tạo chúng trong hàm khởi tạo.
• Truy cập thành viên private từ bên ngoài. c.count = 5; trên một thành viên private là lỗi biên dịch; hãy đi qua một phương thức public. Đó là tính đóng gói đang hoạt động đúng như dự định.
• Nhầm lớp với đối tượng. Dog.bark(); là sai, vì Dog là kiểu. Bạn gọi phương thức trên đối tượng: rex.bark();.

// Uninitialized member - reading 'age' is undefined behavior:
class Cat {
public:
    int age;            // no default value
};

Cat c;
std::cout << c.age;     // garbage value, not 0

Tiếp theo: hàm khởi tạo

Tự gán từng thành viên sau khi tạo đối tượng, như rex.name = ...; rex.age = ...;, vừa tẻ nhạt vừa dễ quên, và đó chính là cách bạn kết thúc với những thành viên chưa khởi tạo. Trang tiếp theo nói về hàm khởi tạo (constructor): những hàm đặc biệt tự chạy khi một đối tượng được tạo, giúp bạn đảm bảo mọi đối tượng đều bắt đầu ở trạng thái hợp lệ với cú pháp gọn gàng chỉ một dòng Dog rex("Rex", 4);.