C++类

C++程式設計允許程式設計師使用類別（class）定義特定程式中的資料類別型。這些資料類別型的實體被稱為物件，這些實體可以包含程式設計師定義的成員變數、常數、成員函式，以及多載的運算子。語法上，類似C中結構體（struct）的擴充，C中結構體不能包含函式以及多載的運算子。

C 結構體與C++ 類別的對比

在 C++ 中，結構體 是由關鍵詞 struct 定義的一種資料類別型。他的成員和基礎類別預設為公有的（public）。由關鍵詞 class 定義的成員和基礎類別預設為私有的（private）。這是C++中結構體和類別僅有的區別。

聚合類別

聚合類別是一種沒有用戶定義的建構函式，沒有私有（private）和保護（protected）非靜態資料成員，沒有基礎類別，沒有虛擬函式。這樣的類別可以由封閉的大括號用逗號分隔開初始化列表。下列的程式碼在 C 和 C++ 具有相同的語法：
struct C{
  int a;
  double b;};struct D{
  int a; 
  double b;
  C c;};// initialize an object of type C with an initializer-listC c = { 1, 2 };// D has a sub-aggregate of type C. In such cases initializer-clauses can be nestedD d = { 10, 20, { 1, 2 } };

POD 結構

一個POD結構（普通舊式資料結構）是一個不包含非POD結構、非POD聯合（或者這些類別型的陣列）或參照的非靜態成員變數（靜態成員沒有限制），並且沒有用戶定義的設定運算子和解構器的聚合類別。 一個POD結構可以說是C struct在C++中的等價物。在大多數情況下，一個POD結構擁有和一個在C中聲明的對應的結構相同的記憶體布局。因此，POD結構有時不正式地被稱為「C風格結構」（C-style struct）。

聲明和使用

C++ 的結構體和類別具有他們自己的成員。這些成員包括變數（包括其他結構體和類別），被看做方法的函式（特定的標示符或多載的運算子），建構函式以及解構函式。成員被聲明成為公共或私有使用說明符public:和private:來區分。說明符後出現的任何成員會獲得相應的存取權限直到下一個說明符的出現。對於繼承的類別能夠使用protected:說明符。

成員函式

成員函式是C++ 的類別和結構體的一個重要特性。這些資料類別型可以包含作為其成員的函式。成員函式分為靜態成員函式與非靜態成員函式。靜態成員函式只能存取該資料類別型的物件的靜態成員。而非靜態成員函式能夠存取物件的所有成員。在非靜態成員函式的函式體內，關鍵詞this指向了呼叫該函式的物件。這通常是通過thiscall呼叫協定，將物件的位址作為隱含的第一個參數傳遞給成員函式。再次以之前的person類別型作為例子：
class person{
  std::string name;
  int age;public:
  person() : age(5) { }
  void print() const;};void person::print() const{
  cout << name << ";" << this->age << endl;
  /* "name"和"age"是成员变量。     "this"关键字的值是被调用对象的地址。其类型为     const person*，原因是该函数被声明为const。  */}
在上面的例子中print()函式在類別中聲明，並在類別的名稱後加上::來限定它後加以定義。name和age是私有的（類別的預設修飾詞），print()被聲明為公有，由於一個被用於類別外的成員需要被申明為公有的。
通過使用成員函式print()，輸出可以被簡化為：
a.print();b.print();
上述的a和b被稱為呼叫者（sender），當print()函式被執行時每一個都參照自己的成員變數。
將類別或結構的申明（稱做介面）和定義（稱作實現）放入分開的單元是常見的做法。用戶需要的介面被放入一個標頭檔中而實現則獨立地放入原始碼或者編譯後的形式。
非靜態成員函式，可以用const或volatile關鍵詞限定。const限定的成員函式不能修改其他資料成員（除了具有mutable的例外），也不能呼叫非const限定的其他成員函式。編譯實現時，通常是在const限定的成員函式體內，this所指向的資料成員自動具有const限定，因此是唯讀的。const物件只能呼叫const成員函式；volatile物件只能呼叫volatile限定的成員函式。反之，沒有受到限定的普通物件可以呼叫所有的成員函式，不論它是否為cv限定。建構函式、解構函式不能cv限定。

繼承

非POD類別的記憶體布局沒有被C++標準規定。例如，許多流行的C++編譯器通過將父類別的欄位和子類別的欄位並置來實現單繼承，但是這並不被標準所需求。這種布局的選擇使得將父類別的指標指向子類別的操作是平凡的（trivial）。
例如，考慮：
class P 
{
    int x;};
class C : public P 
{
    int y;};
一個P的實體和P* p指向它，在記憶體中可能看起來像這樣：
+----+
|P::x|
+----+
↑
p
一個C的實體和P* p指向它，在記憶體中可能看起來像這樣：
+----+----+
|P::x|C::y|
+----+----+
↑
p
因此，任何操縱P物件的欄位的程式碼都可以操縱在C物件中的P欄位而不需要考慮任何關於C欄位的定義。一個正確書寫的C++程式在任何情況下都不應該對被繼承欄位的布局有任何假定。使用static_cast或者dynamic_cast類別型轉換運算子會確保指標正確的從一個類別型轉換為另一個。
多重繼承並不那麼簡單。如果一個類別D繼承了P1和P2，那麼兩個父類別的欄位需要被按照某種順序儲存，但是（在大多數情況下）只有一個父類別可以被放在子類別的頭部。每當編譯器需要將一個指向D的指標轉換為P1或P2中的任一個，編譯器需要提供一個自動轉換從子類別的位址轉換為父類別欄位的位址（典型地，這是一個簡單的偏移量計算）。
關於多重繼承的更多資訊，參看虛繼承。

多載運算子

C++容許程式員重載某些運算子，目的是補充庫中未能提供的針對特定類的運算子。同理，很多時自訂類也因為內建庫不能提供指定運算子而需要重載。
另外，當程式設計師沒有重載或定義某些運算子時，編譯器會自動地建立它們，例如三法則中的複製指定運算子（=）。
依照慣例，重載運算子時應類比運算子本身意義的功能，例如重載運算子「*」時，程式員義務重載為兩數之乘法（或其他，視數學或程式上的意義）。另外，宣告一結構如integer類，當重載運算子如「*」就要回傳integer類：
struct integer 
{
    int i;
    integer(int j = 0) : i(j) {}
    integer operator*(const integer &k) const 
    {
        return integer (i * k.i);
    }};
或
struct integer 
{
    int i;
   
    integer(int j = 0) : i(j) {}
 
    integer operator*(const integer &k) const;};
 
integer integer::operator*(const integer &k) const 
{
    return integer(i * k.i);}
在這裡，const關鍵字出現兩次。表達式const integer &k中的const關鍵字代表函式不能修改此常數值，而第二個const關鍵字代表此函式不會修改類物件本身（*this）。
而integer &k之中，符號（&）表示以參照形式呼叫。當呼叫函式時會直接傳遞變數位址，並以變數本身取代這裡的變數k。

建構函式

有時軟體工程師會想要他們的變數在聲明時有一個預設值。這可以通過聲明建構函式做到。
person(string N, int A) 
{
    name = N;
    age = A;}
成員變數可以像下面的例子一樣，利用一個冒號，通過一個初始化序列初始化。這與上面不同，它進行了初始化（使用建構函式），而不是使用設定運算子。這對類別類別型來說更有效，因為它只需要直接構造；而賦值時，它們必須先使用預設建構函式進行第一次初始化，然後再賦予一個不同的值。而且一些類別型（例如參照和const類別型）不能被賦值，因而必須通過初始化序列進行初始化。
person(std::string N, int A) : name(N), age(A) {}
注意花括號不能被省略，即使為裡面為空。
預設值可以給予最後的幾個參數類別幫助初始化預設值。
person(std::string N = "", int A = 0) : name(N), age(A) {}
在上面的例子中，當沒有參數給予建構函式時，等價於呼叫以下的無參建構函式（一個預設建構函式）：
person() : name(""), age(0) {}
建構函式的聲明看起來像一個名字和資料類別型相同的函式。事實上，我們的確可以用函式呼叫的形式呼叫建構函式。在這種情況下一個person類別型的變數會成為返回值：
int main() 
{
    person r = person("Wales", 40);
    r.print();}
以上的例子建立了一個臨時的person物件，然後使用複製建構函式將其賦予r。一個更好的建立物件的方式（沒有不需要的拷貝）：
int main() 
{
    person r ("Wales", 40);
    r.print ();}
具體的程式行為，可以也可以不和變數有關係，可以被作為一部分加入建構函式。
person() 
{
    std::cout << "Hello!" << endl;}
通過以上的建構函式，當一個person變數沒有被具體的值初始化時，「Hello!」會被列印。

預設建構函式

當類別沒有定義建構函式時，預設建構函式將被呼叫。
class A { int b;};//使用括号创建对象A *a = new A(); //调用默认构造函数，b会被初始化为'0'//不使用括号创建对象A *a = new A; //仅分配内存，不调用默认构造函数，b会有一个未知值
然而如果用戶定義了這個類別建構函式，兩個聲明都會呼叫用戶定義的建構函式。而在用戶定義的建構函式中的程式碼會被執行，並且不會賦予b預設值。

解構函式

一個解構函式是一個建構函式的逆，當一個類別的一個實體被銷毀時會被呼叫，例如當一個類別在塊（一組花括號「{}」)中被構造的一個物件會在關閉括號後刪除，之後解構函式被自動呼叫。它會在清空儲存變數的記憶體位置時被呼叫。解構函式可以在類別被銷毀時用來釋放資源，例如堆分配的記憶體和開啟的檔案。
聲明一個解構函式的符號類別似於建構函式。它沒有返回值而且方法的名稱和在類別的名稱前加上波浪線（~）相同。
~person() 
{
    cout << "I'm deleting " << name << " with age " << age << endl;}
另外要注意的是，析構函式是不容許參數傳遞。然而，與構造函式一樣，析構函式可以被顯式調用：
int main() 
{
    person someone("Wales", 40);
    someone.~person();  //此時會輸出一次"I'm deleting Wales with age 40"

    return 0;  //第二次輸出"I'm deleting  with age 40"}/* 在這裡，程式結束時會自動調用析構函數，   而person.name在第一次調用析構函數時已被清除，   但person.age會按編譯器而定，   沒能在第一次調用析構函數時清零。 */

類別範本

類別範本，是對一批僅僅成員資料類別型不同的類別的抽象，程式設計師只要為這一批類別所組成的整個類別家族建立一個類別範本，給出一套程式碼，就可以用來生成多種具體的類別，這類別可以看作是類別範本的實體，從而大大提高程式設計的效率。

屬性

C++語法試圖使一個結構的所有方面看起來像一個基本資料類別型。因此，運算子多載允許結構像整數和浮點數一樣操作，結構的陣列可以通過方括號聲明（some_structure variable_name[size]），而且指向結構的指標可以通過和指向內建類別型的指標通用的方法解除參照。

記憶體消耗

結構的記憶體消耗至少是組成變數的記憶體大小的總和。參考如下twonums 結構例子。
struct twonums 
{
    int a;
    int b;};
這個結構包含兩個整型。在目前許多 C++ 編譯器中，整型預設是32 位整型， 所以每個成員變數消耗 4 個位元組的記憶體．因而整個結構至少（或者正好）消耗 8 個位元組的記憶體，見下圖。
+----+----+
| a  | b  |
+----+----+
然而，編譯器可能在變數或者結構的結尾添加空的位， 這樣可以保證和給定的電腦結構匹配，通常是把變數添加到 32 位。如下例子所示的結構:
struct bytes_and_such{ 
   char c;
   char C;
   short int s;
   int i;
   double d;};
可看成 
+-+-+--+--+--+--+--------+
|c|C|XX|s |  i  |   d    |
+-+-+--+--+--+--+--------+
在記憶體中, XX 表示兩個未被使用的空位元。
因為結構可能會使用指標和陣列去聲明 或者初始化變數，結構的記憶體消耗不一定是固定的。另外一個記憶體消耗不固定的例子是模板結構。

位欄位

位欄位（Bit field）可以被用來定義比內建類別型還要小的類別成員變數。通過這個欄位定義的變數，只可以像使用內建的整數類別型(例如int, char, short, long...)那樣子使用。
struct A{ 
unsigned a:2; // 可以存储0-3的数字，占据一个int前2 bit的空间.
unsigned b:3; // 可以存储0-7的数字，占据之后3 bit的空间.
unsigned :0;  // 移动到下一个内置类型的末尾
unsigned c:2; 
unsigned :4;  // 在c和d中间加4bit的空白
unsigned d:1;
unsigned e:3;};// 内存结构/*4 byte int   4 byte int[1][2][3][4] [5][6][7][8][1]                   [2]              [3]              [4][a][a][b][b][b][][][] [][][][][][][][] [][][][][][][][] [][][][][][][][][5]                  [6]                [7]              [8][c][c][][][][][d][e] [e][e][][][][][][] [][][][][][][][] [][][][][][][][]*/
位欄位不能在結構體中使用，它只能在使用struct或者class關鍵字定義的類別中使用。

this關鍵字

complex& operator+=(const complex & c) 
{
    realPart += c.realPart;
    imagPart += c.imagPart;
    return *this;}