stanford-oval/wikipedia huggingface dataset:
Sergey Fyodorovich Bondarchuk
Tác phẩm > Đạo diễn

| Năm | Phim | Ghi chú |
| --- | --- | --- |
| 1959 | Số phận một con người (Судьба человека) | Chuyển thể từ tiểu thuyết cùng tên của Mikhail Sholokhov |
| 1968 | Chiến tranh và hòa bình (Война и мир) | Chuyển thể từ tiểu thuyết cùng tên của Lev Tolstoy Giải Oscar cho phim ngoại ngữ hay nhất |
| 1970 | Waterloo (Ватерлоо) | Sản phẩm hợp tác của Liên Xô và Ý |
| 1976 | Họ đã chiến đấu vì Tổ quốc (Они сражались за Родину) | Chuyển thể từ tiểu thuyết cùng tên của Mikhail Sholokhov |
| 1978 | Степь |  |
| 1982 | Красные колокола. Фильм 1. Мексика в огне |  |
| 1986 | Boris Godunov (Борис Годунов) |  |
| 1992 | Sông Đông êm đềm (Тихий Дон) | Chuyển thể từ tiểu thuyết cùng tên của Mikhail Sholokhov Được công chiếu lần đầu năm 2006 |
Trong tất cả các bộ phim trên thì trừ "Số phận một con người" và "Sông Đông êm đềm", các bộ phim còn lại đều do chính Sergei Bondarchuk phụ trách viết kịch bản chuyển thể.
Tác phẩm > Diễn viên

| Năm | Phim | Vai diễn |
| --- | --- | --- |
| 1948 | Đội cận vệ thanh niên (Молодая гвардия) | Валько |
| 1950 | Кавалер Золотой Звезды | Сергей Тутаринов |
| 1951 | Taras Shevchenko (Тарас Шевченко) | Taras Shevchenko |
| 1953 | Адмирал Ушаков | Тихон Прокофьев |
| 1953 | Корабли штурмуют бастионы | Тихон Прокофьев |
| 1955 | Неоконченная повесть |  |
| 1955 | Othello (Отелло) | Othello |
| 1955 | Попрыгунья | Осип Степанович Дымов |
| 1958 | Шли солдаты |  |
| 1959 | Số phận một con người (Судьба человека) | Andrei Sokolov |
| 1960 | Серёжа | Коростылёв |
| 1968 | Chiến tranh và hòa bình (Война и мир) | Pierre Bezukhov |
| 1969 | Золотые ворота |  |
| 1969 | Битва на Неретве | Мартын |
| 1970 | Дядя Ваня | Астров |
| 1973 | Молчание доктора Ивенса |  |
| 1974 | Такие высокие горы |  |
| 1975 | Выбор цели | Курчатов |
| 1976 | Họ đã chiến đấu vì Tổ quốc (Они сражались за Родину) | Звягинцев |
| 1977 | Пошехонская старина |  |
| 1978 | Степь |  |
| 1978 | Бархатный сезон |  |
| 1978 | Отец Сергий |  |
| 1979 | Взлёт |  |
| 1979 | Профессия | киноактёр |
| 1980 | Овод | кардинал Монтанелли |
| 1986 | Boris Godunov (Борис Годунов) | Boris Godunov |
| 1988 | Случай в аэропорту |  |
| 1990 | Битва трёх королей |  |
| 1992 | Гроза над Русью |  |
Ordgarius clypeatus

| Ordgarius clypeatus> Phân loại khoa học |
| --- | --- |
Giới (regnum): Animalia
Ngành (phylum): Arthropoda
Phân ngành (subphylum): Chelicerata
(không phân hạng): Arachnomorpha
Lớp (class): Arachnida
Bộ (ordo): Araneae
Họ (familia): Araneidae
Chi (genus): Ordgarius
Loài (species): O. clypeatus
Danh pháp hai phần
Ordgarius clypeatus Simon, 1897 
Ordgarius clypeatus là một loài nhện trong họ Araneidae.
Loài này thuộc chi Ordgarius. Ordgarius clypeatus được Eugène Simon miêu tả năm 1897.
Chú thích

↑  Platnick, Norman I. (2010): The world spider catalog, version 10.5. American Museum of Natural History.
Osseo, Minnesota

| Osseo, Minnesota |
| --- | --- |
—  Thành phố  —
 

 
 Vị trí trong Quận Hennepin, Minnesota
 Vị trí bang Minnesota ở Hoa Kỳ
Osseo, Minnesota
Quốc gia: Hoa Kỳ
Tiểu bang: Minnesota
Quận: Quận Hennepin
Dân số (2010)
 • Tổng cộng: 2.430
Múi giờ: CST (UTC-6)
 • Mùa hè (DST): CDT (UTC-5)
Mã điện thoại: 763 
Osseo là một thành phố thuộc quận Hennepin, tiểu bang Minnesota, Hoa Kỳ. Năm 2010, dân số của thành phố này là 2430 người.
Dân số

Dân số năm 2000: 2434 người.
Dân số năm 2010: 2430 người.
Chú thích

↑  “2010 Census Gazetteer Files”. Cục Thống kê Dân số Hoa Kỳ. Truy cập ngày 15 tháng 10 năm 2012.
Falsoropica javaensis

| Falsoropica javaensis> Phân loại khoa học |
| --- | --- |
Giới (regnum): Animalia
Ngành (phylum): Arthropoda
Lớp (class): Insecta
Bộ (ordo): Coleoptera
Phân bộ (subordo): Polyphaga
Liên họ (superfamilia): Cerambycoidea
Họ (familia): Cerambycidae
Chi (genus): Falsoropica
Loài (species): F. javaensis
Danh pháp hai phần
Falsoropica javaensis Breuning, 1982 
Falsoropica javaensis là một loài bọ cánh cứng trong họ Cerambycidae.
Chú thích

↑  Bisby, F.A.; Roskov, Y.R.; Orrell, T.M.; Nicolson, D.; Paglinawan, L.E.; Bailly, N.; Kirk, P.M.; Bourgoin, T.; Baillargeon, G.; Ouvrard, D. (2011). “Species 2000 & ITIS Catalogue of Life: 2011 Annual Checklist”. Species 2000: Reading, UK. Truy cập ngày 24 tháng 9 năm 2012.
Laemophloeus ubiquitosus

| Laemophloeus ubiquitosus> Phân loại khoa học |
| --- | --- |
Giới (regnum): Animalia
Ngành (phylum): Arthropoda
Lớp (class): Insecta
Bộ (ordo): Coleoptera
Họ (familia): Laemophloeidae
Chi (genus): Laemophloeus
Loài (species): L. ubiquitosus
Danh pháp hai phần
Laemophloeus ubiquitosus Lea, 1904 
Laemophloeus ubiquitosus là một loài bọ cánh cứng trong họ Laemophloeidae. Loài này được Lea miêu tả khoa học năm 1904.
Chú thích

↑  Hallan, J.  (2010) Synopsis of the described Coleoptera of the World 6 juni 2010
Class trong C++

Class trong C++ là khái niệm được người dùng định nghĩa như một kiểu dữ liệu đơn giản hay một cấu trúc dữ liệu, được khai báo bằng từ khóa class, nó chứa các biến (còn gọi là thuộc tính) hay các hàm (còn gọi là phương thức). Các phần tử của class được quản lý bởi ba thuộc tính truy cập: private, protected hoặc public (thuộc tính mặc định khi truy cập vào một phần tử trong class là private). Các phần tử private không thể được truy cập bên ngoài class mà chỉ có thể được truy cập thông qua các phương thức của class chứa chúng. Ngược lại, các phần tử public có thể được truy cập ở bất kỳ class nào.
Thể hiện của một kiểu dữ liệu lớp được gọi là các đối tượng và có thể chứa các biến, hằng, hàm thành viên và nạp chồng toán tử được xác định bởi lập trình viên.
Sự khác nhau giữa kiểu cấu trúc (struct) và lớp (class) trong C++

Trong C++, một lớp được định nghĩa với từ khóa class và theo mặc định, nó có các phần tử private. Một cấu trúc được định nghĩa với từ khóa struct, theo mặc định, các thành viên của struct có thuộc tính truy cập kiểu public.
Lớp tổng hợp

Một lớp tổng hợp là một lớp không có khai báo bộ khởi tạo, không có thuộc tính truy cập riêng tư hay bảo vệ của các thành viên dữ liệu không tĩnh, không có các lớp cơ sở, không có phương thức ảo. Như vậy một lớp có thể được khởi tạo bằng cách gán thể hiện của lớp bằng một danh sách lần lượt các giá trị thuộc tính ngăn cách nhau bởi dấu phẩy, danh sách này được bao quanh bởi cặp dấu ngoặc nhọn. Đoạn code dưới đây có cùng ý  nghĩa trong C và C++.
struct C {
  int a;
  double b;
};

struct D {
  int a; 
  double b;
  C c;
};

//  khởi tạo một đối tượng kiểu C với một danh sách khởi tạo
C c = {1, 2.0};

/* D có một tập hợp con của loại C. Trong những trường 
hợp như vậy, các mệnh đề khởi tạo có thể được lồng vào nhau  */
D d = {10, 20.0, {1, 2.0}};
Lớp tổng hợp > Cấu trúc POD

Cấu trúc POD (Cấu trúc dữ liệu cũ thuần túy) là một lớp tổng hợp không có thành viên dữ liệu không tĩnh thuộc kiểu non-POD-struct, non-POD-union (hoặc mảng thuộc các kiểu như vậy) hoặc tham chiếu và không có người dùng - toán tử gán được xác định và không có trình hủy do người dùng xác định. Một cấu trúc POD có thể được cho là tương đương với C ++ của cấu trúc C. Trong hầu hết các trường hợp, cấu trúc POD sẽ có cùng bố cục bộ nhớ với cấu trúc tương ứng được khai báo trong C. Vì lý do này, cấu trúc POD đôi khi được gọi một cách thông tục là "cấu trúc kiểu C"
Thuộc tính được chia sẻ giữa cấu trúc trong C và cấu trúc POD trong C++
Các thành viên dữ liệu được cấp phát để các thành viên sau này có địa chỉ cao hơn trong một đối tượng, ngoại trừ trường hợp được phân tách bởi một chỉ định truy cập.
Hai kiểu cấu trúc POD tương thích với bố cục nếu chúng có cùng số lượng thành viên dữ liệu không tĩnh và các thành viên dữ liệu không tĩnh tương ứng (theo thứ tự) có kiểu tương thích với bố cục.
Cấu trúc POD có thể chứa phần đệm không tên.
Một con trỏ đến đối tượng cấu trúc POD, được chuyển đổi phù hợp bằng cách sử dụng diễn giải lại, trỏ đến thành viên ban đầu của nó và ngược lại, ngụ ý rằng không có phần đệm ở đầu cấu trúc POD.
Một cấu trúc POD có thể được sử dụng với macro offset.
Khai báo và sử dụng

Các lớp C++ có các thành viên riêng của chúng. Các thành viên này bao gồm các biến (bao gồm các cấu trúc và lớp khác), các hàm (các định danh cụ thể hoặc các toán tử nạp chồng) được gọi là các phương thức, các hàm tạo và các hàm hủy. Các thành viên được tuyên bố là có thể truy cập công khai hoặc riêng tư bằng cách sử dụng công cụ xác định quyền truy cập public: và private: tương ứng. Bất kỳ thành viên nào gặp sau một mã xác định sẽ có quyền truy cập liên quan cho đến khi gặp một bộ chỉ định khác. Ngoài ra còn có sự kế thừa giữa các lớp có thể sử dụng protected:
Khai báo và sử dụng > Lớp toàn cục và lớp cục bộ

Một lớp được định nghĩa bên ngoài tất cả các phương thức là một lớp toàn cục vì các đối tượng của nó có thể được tạo từ bất kỳ đâu trong chương trình. Nếu nó được định nghĩa trong một thân hàm thì đó là một lớp cục bộ vì các đối tượng của lớp như vậy là cục bộ đối với phạm vi hàm.
Khai báo và sử dụng > Khai báo cơ bản và các biến thành viên

Các lớp được khai báo với từ khóa class hoặc struct. Tuyên bố của các thành viên được đặt trong tuyên bố này.
struct Person {

  string name;
  int age;
};
class Person {
 public:
  string name;
  int age;
};
Các định nghĩa trên là tương đương về mặt chức năng. Một trong hai mã sẽ xác định các đối tượng kiểu Person là có hai thành viên dữ liệu công khai, name  và  age. Dấu chấm phẩy sau dấu ngoặc nhọn là bắt buộc.

Sau một trong các khai báo này (nhưng không phải cả hai), Person có thể được sử dụng như sau để tạo các biến mới được xác định của kiểu dữ liệu Person:
#include <iostream>
#include <string>

struct Person {
  std::string name;
  int age;
};

int main() {
  Person a;
  Person b;
  a.name = "Calvin";
  b.name = "Hobbes";
  a.age = 30;
  b.age = 20;
  std::cout << a.name << ": " << a.age << std::endl;
  std::cout << b.name << ": " << b.age << std::endl;
}
Khi chạy chương trình trên sẽ in ra màn hình:
Calvin: 30
Hobbes: 20
Khai báo và sử dụng > Chức năng thành viên

Một tính năng quan trọng của lớp và cấu trúc C ++ là các hàm thành viên. Mỗi kiểu dữ liệu có thể có các hàm tích hợp riêng của nó (được gọi là các phương thức) có quyền truy cập vào tất cả các thành viên (public và private) của kiểu dữ liệu. Trong phần thân của các hàm thành viên không tĩnh này, từ khóa this có thể được sử dụng để tham chiếu đến đối tượng mà hàm được gọi. Điều này thường được thực hiện bằng cách chuyển địa chỉ của đối tượng như một đối số ngầm định đầu tiên cho hàm. Lấy kiểu Person ở trên làm ví dụ một lần nữa:
#include <iostream>

class Person {
 public:
  void Print() const;

 private:
  std::string name_;
  int age_ = 5;
};

void Person::Print() const {
  std::cout << name_ << ":" << age_ << std::endl;
  // "name_" và "age_" là các biến thành viên. Từ "keyword" là
  // biểu thức có giá trị là địa chỉ của đối tượng mà thành viên
  // đã được gọi. Kiểu của nó là "const Person *", vì hàm được khai báo hằng số
Trong ví dụ trên, hàm Print được khai báo trong phần thân của lớp và được định nghĩa bằng cách định nghĩa nó với tên của lớp theo sau là ::. Cả name_ và age_ đều là private (mặc định cho lớp) và Print được khai báo là public, cần thiết nếu nó được sử dụng từ bên ngoài lớp.

Với chức năng thành viên Print, việc in ấn có thể được đơn giản hóa thành:
a.Print();
b.Print();
Trong đó a và b ở trên được gọi là người gửi và mỗi người trong số họ sẽ tham chiếu đến các biến thành viên của riêng chúng khi hàm Print() được thực thi.
Thực tế phổ biến là tách khai báo lớp hoặc cấu trúc (được gọi là giao diện của nó) và định nghĩa (được gọi là hiện thực của nó) thành các đơn vị riêng biệt. Giao diện, được người dùng cần, được giữ trong tiêu đề và việc triển khai được giữ riêng ở dạng nguồn hoặc dạng biên dịch.
Khai báo và sử dụng > Sự thừa kế

Việc bố trí các lớp không phải POD trong bộ nhớ không được tiêu chuẩn C ++ chỉ định. Ví dụ, nhiều trình biên dịch C ++ phổ biến thực hiện kế thừa đơn bằng cách nối các trường lớp cha với các trường lớp con, nhưng tiêu chuẩn này không yêu cầu. Lựa chọn bố cục này làm cho việc tham chiếu đến một lớp dẫn xuất thông qua một con trỏ đến kiểu lớp cha là một hoạt động tầm thường.
Ví dụ, hãy xem xét
struct P {
  int x;
};
struct C : P {
  int y;
};
Một ví dụ của P với P* p trỏ tới nó có thể trông như thế này trong bộ nhớ:
+----+
|P::x|
+----+
↑
p
Một ví dụ của C với P* p trỏ đến nó có thể trông như thế này:
+----+----+
|P::x|C::y|
+----+----+
↑
p
Do đó, bất kỳ mã nào thao tác với các trường của một đối tượng P đều có thể thao tác các trường P bên trong đối tượng C mà không cần phải xem xét bất kỳ điều gì về định nghĩa các trường của C. Một chương trình C++ được viết đúng cách không nên đưa ra bất kỳ giả định nào về bố cục của các trường kế thừa, trong mọi trường hợp. Sử dụng toán tử chuyển đổi kiểu static_cast hoặc dynamic_cast sẽ đảm bảo rằng các con trỏ được chuyển đổi đúng cách từ kiểu này sang kiểu khác.
Đa kế thừa không phải là đơn giản. Nếu một lớp D kế thừa P và C, thì các trường của cả hai trường cha mẹ cần được lưu trữ theo một số thứ tự, nhưng (tối đa) chỉ một trong các lớp cha có thể được đặt ở phía trước của lớp dẫn xuất. Bất cứ khi nào trình biên dịch cần chuyển đổi con trỏ từ kiểu D sang P hoặc C, trình biên dịch sẽ cung cấp chuyển đổi tự động từ địa chỉ của lớp dẫn xuất sang địa chỉ của các trường lớp cơ sở (thông thường, đây là một phép tính bù đơn giản).
Để biết thêm về đa kế thừa, hãy xem kế thừa ảo.
Khai báo và sử dụng > Nạp chồng toán tử

Trong C++, các toán tử, chẳng hạn như + - * /, có thể được nạp chồng để phù hợp với nhu cầu của người lập trình. Các toán tử này được gọi là toán tử có thể nạp chồng.
Theo quy ước, các toán tử được nạp chồng sẽ hoạt động gần giống như chúng hoạt động trong các kiểu dữ liệu dựng sẵn (int, float, v.v.), nhưng điều này là không bắt buộc. Người ta có thể khai báo một cấu trúc gọi là Integer, trong đó biến thực sự lưu trữ một số nguyên, nhưng bằng cách gọi Integer * Integer, tổng, thay vì tích, của các số nguyên có thể được trả về:
struct Integer {
  Integer(int j = 0): i(j) {}

  Integer operator*(const Integer& k) const {
    return Integer(i + k.i);
  }

  int i;
};
Đoạn mã trên đã sử dụng một hàm tạo để "tạo" giá trị trả về. Để trình bày rõ ràng hơn (mặc dù điều này có thể làm giảm hiệu quả của chương trình nếu trình biên dịch không thể tối ưu hóa câu lệnh thành câu lệnh tương đương ở trên), đoạn mã trên có thể được viết lại thành:
Integer operator*(const Integer& k) const {
  Integer m;
  m.i = i + k.i;
  return m;
}
Lập trình viên cũng có thể đặt một nguyên mẫu của toán tử trong khai báo struct và xác định chức năng của toán tử trong phạm vi toàn cục:
struct Integer {
  Integer(int j = 0): i(j) {}

  Integer operator*(const Integer& k) const;

  int i;
};
 
Integer Integer::operator*(const Integer& k) const {
  return Integer(i * k.i);
}
i ở trên đại diện cho biến thành viên của chính người gửi, trong khi k.i đại diện cho biến thành viên từ biến đối số k.
Từ khóa const xuất hiện hai lần trong đoạn mã trên. Lần xuất hiện đầu tiên, đối số const integer& k, chỉ ra rằng biến đối số sẽ không bị thay đổi bởi hàm. Tỷ lệ thứ hai ở cuối khai báo hứa với trình biên dịch rằng người gửi sẽ không bị thay đổi bởi hàm chạy.
Trong const integer& k, dấu và (&) có nghĩa là "chuyển qua tham chiếu". Khi hàm được gọi, một con trỏ tới biến sẽ được chuyển tới hàm, thay vì giá trị của biến.
Các thuộc tính nạp chồng tương tự ở trên cũng áp dụng cho các lớp.
Lưu ý rằng không thể thay đổi độ hiếm, tính liên kết và thứ tự ưu tiên của các toán tử.
Khai báo và sử dụng > Nạp chồng toán tử > Nạp chồng toán tử nhị phân

Toán tử nhị phân (toán tử có hai đối số) được nạp chồng bằng cách khai báo một hàm với một toán tử "định danh" (một cái gì đó) gọi một đối số duy nhất. Biến ở bên trái của toán tử là người gửi trong khi ở bên phải là đối số.
Integer i = 1; 
/* chúng ta có thể khởi tạo một biến cấu trúc theo cách 
   này nếu gọi một hàm tạo chỉ có đối số được chỉ định. */
Integer j = 3;
/* tên biến độc lập với tên của
   các biến thành viên của cấu trúc. */
Integer k = i * j;
std::cout << k.i << std::endl;
Sẽ in ra màn hình là
3
Sau đây là danh sách các toán tử có thể nạp chồng nhị phân:
| Toán tử | Công dụng chung |
| --- | --- |
+ - * / %: Tính toán số học
^ & | << >>: Tính toán thao tác bit
< > == != <= >=: So sánh logic
&&: Kết hợp logic
||: Sự phân chia logic
 += -= *= /= %=^= &= |= <<= >>=: Phân công tổng hợp
,: (không sử dụng chung)
Toán tử '=' (gán) giữa hai biến có cùng kiểu cấu trúc được nạp chồng theo mặc định để sao chép toàn bộ nội dung của biến từ biến này sang biến khác. Nó có thể được ghi đè bằng thứ khác, nếu cần.
Các toán tử phải được nạp chồng từng cái một, nói cách khác, không có quá tải nào được liên kết với nhau. Ví dụ, <không nhất thiết phải ngược lại với>.
Khai báo và sử dụng > Nạp chồng toán tử > Toán tử có thể nạp chồng một lần

Trong khi một số toán tử, như được chỉ định ở trên, nhận hai điều khoản, người gửi ở bên trái và đối số ở bên phải, một số toán tử chỉ có một đối số - người gửi và chúng được cho là "một ngôi". Ví dụ là dấu phủ định (khi không có gì được đặt ở bên trái của nó) và "logic NOT" (dấu chấm than,!).
Người gửi của toán tử một ngôi có thể ở bên trái hoặc bên phải của nhà khai thác. Sau đây là danh sách các toán tử có thể nạp chồng một lần:
| Toán tử | Công dụng chung | Vị trí sử dụng |
| --- | --- | --- |
| + - | Cộng / trừ | phải |
| * & | Con trỏ | phải |
| ! ~ | Logical / bitwise NOT | phải |
| ++ -- | Tăng / giảm trước | phải |
| ++ -- | Tăng / giảm sau | trái |
Cú pháp nạp chồng toán tử một ngôi, trong đó người gửi ở bên phải, như sau:
Kiểu_trả_về toán_tử@ ()
Khi người gửi ở bên trái, khai báo là:
kiểu_trả_về toán_tử@ (int)
@ trên là viết tắt của toán tử được quá tải. Thay thế return_type bằng kiểu dữ liệu của giá trị trả về (int, bool, cấu trúc, v.v.)
Tham số int về cơ bản không có nghĩa gì ngoài một quy ước để cho thấy rằng người gửi ở bên trái của toán tử.
Đối số const có thể được thêm vào cuối khai báo nếu có.
Khai báo và sử dụng > Nạp chồng toán tử > Mảng có thể nạp chồng

Dấu ngoặc vuông [] và dấu ngoặc tròn () có thể được nạp chồng trong cấu trúc C++. Dấu ngoặc vuông phải chứa chính xác một đối số, trong khi dấu ngoặc tròn có thể chứa bất kỳ số lượng đối số cụ thể nào hoặc không có đối số nào.
Khai báo mảng có thể nạp chồng
Kiểu_trả_về toán_tử[] (tham số)
Nội dung bên trong dấu ngoặc được chỉ định trong tham số.
Dấu ngoặc tròn được nạp chồng theo cách tương tự.
Kiểu_trả_về toán_tử() (tham_số_1,tham_số_2,...)
Nội dung của dấu ngoặc trong lệnh gọi nhà điều hành được chỉ định trong dấu ngoặc thứ hai.
Ngoài các toán tử được chỉ định ở trên, toán tử mũi tên (->), mũi tên có dấu sao (-> *), từ khóa new và từ khóa delete cũng có thể được nạp chồng. Các toán tử liên quan đến bộ nhớ hoặc con trỏ này phải xử lý các chức năng cấp phát bộ nhớ sau khi nạp chồng. Giống như toán tử gán (=), chúng cũng được nạp chồng theo mặc định nếu không có khai báo cụ thể.
Khai báo và sử dụng > Hàm tạo

Đôi khi các lập trình viên có thể muốn các biến của họ nhận một giá trị mặc định hoặc một giá trị cụ thể khi khai báo. Điều này có thể được thực hiện bằng cách khai báo các hàm tạo.
Person::Person(string name, int age) {
  name_ = name;
  age_ = age;
}
Các biến thành viên có thể được khởi tạo trong danh sách trình khởi tạo, với việc sử dụng dấu hai chấm, như trong ví dụ dưới đây. Điều này khác với ở trên ở chỗ nó khởi tạo (sử dụng hàm tạo), thay vì sử dụng toán tử gán. Điều này hiệu quả hơn đối với các loại lớp, vì nó chỉ cần được xây dựng trực tiếp; trong khi với phép gán, chúng phải được khởi tạo đầu tiên bằng cách sử dụng hàm tạo mặc định, sau đó được gán một giá trị khác. Ngoài ra, một số kiểu (như tham chiếu và kiểu const) không thể được gán cho và do đó phải được khởi tạo trong danh sách trình khởi tạo.
Person(std::string name, int age) : name_(name), age_(age) {}
Lưu ý rằng không thể bỏ qua dấu ngoặc nhọn, ngay cả khi trống.

Giá trị mặc định có thể được cấp cho các đối số cuối cùng để giúp khởi tạo các giá trị mặc định.
Person(std::string name = "", int age = 0) : name_(name), age_(age) {}
Khi không có đối số nào được cung cấp cho hàm tạo trong ví dụ trên, nó tương đương với việc gọi hàm tạo sau không có đối số (một hàm tạo mặc định):
Person() : name_(""), age_(0) {}
Khai báo của một phương thức khởi tạo trông giống như một hàm có cùng tên với kiểu dữ liệu. Trên thực tế, một lời gọi đến một phương thức khởi tạo có thể ở dạng một lời gọi hàm. Trong trường hợp đó, một biến kiểu Person được khởi tạo có thể được coi là giá trị trả về:
int main() {
  Person r = Person("Wales", 40);
  r.Print();
}
Một cú pháp thay thế thực hiện tương tự như ví dụ trên là
int main() {
  Person r("Wales", 40);
  r.Print();
}
Các hành động chương trình cụ thể, có thể có hoặc không liên quan đến biến, có thể được thêm vào như một phần của hàm tạo.
Person() {
  std::cout << "Hello!" << std::endl;
}
Với hàm tạo ở trên, "Xin chào!" sẽ được in khi phương thức khởi tạo Person mặc định được gọi.
Khai báo và sử dụng > Hàm tạo > Hàm tạo mặc định

Các hàm tạo mặc định được gọi khi các hàm tạo không được định nghĩa cho các lớp.
struct A {
  int b;
};
// Đối tượng được tạo bằng cách sử dụng dấu ngoặc đơn.
A* a = new A();  // Gọi hàm tạo mặc định và b sẽ được khởi tạo bằng '0'.
// Đối tượng được tạo không sử dụng dấu ngoặc đơn.
A* a = new A;  // Phân bổ bộ nhớ, sau đó gọi hàm tạo mặc định và b sẽ có giá trị '0'.
// Tạo đối tượng mà không cần new.
A a;  // Dành không gian cho a trên ngăn xếp và b sẽ có giá trị rác không xác định.
Tuy nhiên, nếu một hàm tạo do người dùng xác định được định nghĩa cho lớp, thì cả hai khai báo trên sẽ gọi hàm tạo do người dùng xác định này, mà mã được xác định sẽ được thực thi, nhưng không có giá trị mặc định nào được gán cho biến b.
Khai báo và sử dụng > Hàm hủy

Một hàm hủy là nghịch đảo của một hàm tạo. Nó được gọi khi một thể hiện của lớp bị hủy, ví dụ: khi một đối tượng của một lớp được tạo trong một khối (tập hợp các dấu ngoặc nhọn "{}") bị xóa sau dấu ngoặc nhọn đóng, thì hàm hủy được gọi tự động. Nó sẽ được gọi khi làm trống vị trí bộ nhớ lưu các biến. Bộ hủy có thể được sử dụng để giải phóng tài nguyên, chẳng hạn như bộ nhớ được cấp phát theo đống và các tệp đã mở khi một thể hiện của lớp đó bị hủy.
Cú pháp để khai báo một hàm hủy tương tự như cú pháp của một hàm tạo. Không có giá trị trả về và tên của phương thức giống với tên của lớp có dấu ngã (~) ở phía trước.
~Person() {
  std::cout << "I'm deleting " << name_ << " with age " << age_ << std::endl;
}
Điểm giống nhau giữa hàm tạo và hàm hủy

Cả hai đều có cùng tên với lớp mà chúng được khai báo.
Nếu không được khai báo bởi người dùng, cả hai đều có sẵn trong một lớp theo mặc định nhưng bây giờ họ chỉ có thể cấp phát và phân bổ bộ nhớ từ các đối tượng của một lớp khi một đối tượng được khai báo hoặc xóa.
Đối với một lớp dẫn xuất: Trong thời gian chạy của hàm tạo lớp cơ sở, hàm tạo của lớp dẫn xuất vẫn chưa được gọi; trong thời gian chạy của hàm hủy lớp cơ sở, hàm hủy lớp dẫn xuất đã được gọi. Trong cả hai trường hợp, các biến thành viên của lớp dẫn xuất ở trạng thái không hợp lệ.
Class template

Trong C++, khai báo lớp có thể được tạo từ các class template Các class template như vậy đại diện cho một họ các lớp. Khai báo lớp thực sự có được bằng cách khởi tạo mẫu với một hoặc nhiều đối số mẫu. Một khuôn mẫu được khởi tạo với một tập hợp các đối số cụ thể được gọi là chuyên môn hóa khuôn mẫu.
Tính chất

Cú pháp của C ++ cố gắng làm cho mọi khía cạnh của cấu trúc trông giống như các kiểu dữ liệu cơ bản. Do đó, các toán tử nạp chồng cho phép các cấu trúc được thao tác giống như số nguyên và số dấu phẩy động, mảng cấu trúc có thể được khai báo bằng cú pháp ngoặc vuông (một_số_cấu trúc tên_biến[size]) và con trỏ đến cấu trúc có thể được tham chiếu theo cách tương tự như con trỏ tới các kiểu dữ liệu tích hợp sẵn.