C++六大默認成員函數的實現(xiàn)

更新時間：2025年02月07日 08:57:08 作者：落水 zh

C++中的六大默認成員函數包括默認構造函數、默認析構函數、默認拷貝構造函數、默認拷貝賦值運算符、移動構造函數和移動賦值運算符,本文就來介紹一下這些函數的使用,感興趣的可以了解一下

默認構造函數

作用：初始化對象，當類沒有顯式定義任何構造函數時生成。
生成條件：用戶未定義任何構造函數。
注意：若類有其他構造函數（如帶參數的構造函數），需顯式使用 = default 聲明默認構造函數。

class Person
{
public:
	//Person()
	//{

	//} 不寫的話默認自動生成
	void GetAge()
	{
		std::cout << _age << std::endl;
	}
private:
	int _age;
};

int main()
{
	Person p;
	p.GetAge();
}

其特征如下：

函數名與類名相同。

無返回值。

對象實例化時編譯器自動調用對應的構造函數。

構造函數可以重載。

如果類中沒有顯式定義構造函數，則C++編譯器會自動生成一個無參的默認構造函數，一旦用戶顯式定義編譯器將不再生成。

編譯器生成默認的構造函數會對自定類型成員調用的它的默認成員
函數。C++11 中針對內置類型成員不初始化的缺陷，又打了補丁，即：內置類型成員變量在類中聲明時可以給默認值。

默認析構函數

作用：釋放對象資源，默認析構函數調用成員變量的析構函數。
生成條件：用戶未定義析構函數。
注意：若類管理動態(tài)資源（如堆內存），需自定義析構函數以避免內存泄漏

class Person
{
public:
	//Person()
	//{

	//} 不寫的話默認自動生成
	void GetAge()
	{
		std::cout << _age << std::endl;
	}

	~Person()
	{

	}
private:
	int _age;
};

int main()
{
	Person p;
	p.GetAge();
}

RAII技術

RAII（Resource Acquisition Is Initialization，資源獲取即初始化）是C++中一種管理資源的編程技術。它通過將資源的生命周期與對象的生命周期綁定在一起，利用C++的構造函數和析構函數來自動管理資源，從而避免了手動分配和釋放資源可能帶來的問題，如內存泄漏、資源未正確釋放等。

RAII的核心思想

資源在對象構造時獲取：當一個對象被創(chuàng)建時，它的構造函數負責獲取所需的資源（例如，動態(tài)內存分配、文件打開、網絡連接等）。
資源在對象銷毀時釋放：當對象離開作用域或被顯式刪除時，其析構函數會自動釋放之前獲取的資源。

優(yōu)點

異常安全性：由于資源管理由構造和析構函數自動處理，即使程序中拋出了異常，也能確保資源得到正確釋放。
簡化代碼：開發(fā)者不需要手動跟蹤每個資源的狀態(tài)，并且可以在不使用顯式的try-finally塊的情況下保證資源的釋放。
防止資源泄露：只要對象被正確地創(chuàng)建并最終銷毀，資源就會被正確釋放。

示例

以下是一個簡單的例子，展示了如何使用RAII來管理動態(tài)分配的內存：

#include <iostream>

class ResourceHandler {
private:
    int* data;
public:
    // 構造函數：資源獲取
    ResourceHandler() {
        data = new int(10); // 分配資源
        std::cout << "Resource acquired." << std::endl;
    }

    // 析構函數：資源釋放
    ~ResourceHandler() {
        delete data; // 釋放資源
        std::cout << "Resource released." << std::endl;
    }

    void showData() const {
        std::cout << "Data: " << *data << std::endl;
    }
};

void useResource() {
    ResourceHandler handler;
    handler.showData();
    // 不需要手動釋放資源，handler離開作用域時會自動調用析構函數
}

int main() {
    useResource();
    return 0;
}

在這個例子中，ResourceHandler類負責管理一個整數類型的動態(tài)分配內存。構造函數在對象創(chuàng)建時分配資源，而析構函數在對象銷毀時釋放這些資源。這樣就確保了無論函數useResource如何退出（正常結束或因異常退出），資源都會被正確釋放。

應用場景

RAII不僅限于內存管理，還可以應用于其他資源類型，如文件句柄、網絡套接字、數據庫連接等。標準庫中的智能指針（如std::unique_ptr、std::shared_ptr）、鎖機制（如std::lock_guard、std::unique_lock）都是RAII原則的實際應用案例。通過使用這些工具，可以有效地減少資源管理錯誤，提高代碼的安全性和可靠性。

默認拷貝構造

聲明形式：ClassName(const ClassName&)
作用：通過已有對象初始化新對象，默認執(zhí)行淺拷貝。
生成條件：用戶未定義拷貝構造函數。
注意：若類包含指針或動態(tài)資源，需自定義深拷貝防止重復釋放。

class Person
{
public:
	Person()
	{

	}

	Person(const Person& person)
	{
		this->_age = person._age;
	}

	~Person()
	{

	}

	void GetAge()
	{
		std::cout << _age << std::endl;
	}
private:
	int _age;
};

int main()
{
	Person p;
	p.GetAge();
}

深拷貝和淺拷貝

class Stack
{
public:
	//初始化
	Stack()
	{
		_array = new int[20];
	}

	//默認生成拷貝構造

	//析構
	~Stack()
	{
		delete[] _array;
	}
private:
	int* _array;
	size_t _size;
	size_t _capacity;
};

int main()
{
	Stack s1;

	Stack s2(s1);
}

這里我沒有寫實際的拷貝構造函數，這里s2調用的默認的拷貝構造，所以s2_array的地址就是s1中_array的地址，這就叫淺拷貝：

在這里插入圖片描述

這樣代碼就會有問題，因為一個地址會被析構兩次：

在這里插入圖片描述

正確的方法應該是給s2的array開辟一塊新的空間：

class Stack
{
public:
	//初始化
	Stack()
	{
		_array = new int[20];
	}

	Stack(const Stack& st)
	{
		_array = new int[10];
		_size = st._size;
		_capacity = st._capacity;
	}

	//析構
	~Stack()
	{
		delete[] _array;
	}
private:
	int* _array;
	size_t _size;
	size_t _capacity;
};

int main()
{
	Stack s1;

	Stack s2(s1);
}

在這里插入圖片描述

這樣的拷貝我們稱為深拷貝，再次運行程序：

在這里插入圖片描述

默認拷貝賦值運算符

聲明形式：ClassName& operator=(const ClassName&)
作用：將已有對象的值賦給另一個對象，默認淺拷貝。
生成條件：用戶未定義拷貝賦值運算符。
注意：需處理自賦值問題，并在資源管理時實現(xiàn)深拷貝。

class Stack
{
public:
	//初始化
	Stack()
	{
		_array = new int[20];
	}

	Stack(const Stack& st)
	{
		_array = new int[10];
		_size = st._size;
		_capacity = st._capacity;
	}

	Stack& operator=(const Stack& st)
	{
		if (this != &st)
		{
			_array = new int[10];
			_size = st._size;
			_capacity = st._capacity;
		}

		return *this;

	}

	//析構
	~Stack()
	{
		delete[] _array;
	}
private:
	int* _array;
	size_t _size;
	size_t _capacity;
};

int main()
{
	Stack s1;

	Stack s2;

	s2 = s1;
}

在這里插入圖片描述

移動構造函數（C++11起）

聲明形式：ClassName(ClassName&&)
作用：通過右值引用“竊取”資源，避免深拷貝開銷。
生成條件：用戶未定義拷貝操作、移動操作或析構函數。
注意：移動后源對象應處于有效但未定義狀態(tài)（如空指針）。

class Stack
{
public:
	//初始化
	Stack()
	{
		_array = new int[20];
	}

	Stack(const Stack& st)
	{
		_array = new int[10];
		_size = st._size;
		_capacity = st._capacity;
	}

	Stack& operator=(const Stack& st)
	{
		if (this != &st)
		{
			_array = new int[10];
			_size = st._size;
			_capacity = st._capacity;
		}

		return *this;

	}

	void swap(Stack& st)
	{
		std::swap(_array, st._array);
		std::swap(_size, st._size);
		std::swap(_capacity, st._capacity);
	}

	//移動構造函數
	Stack(Stack&& st):_array(nullptr), _size(0), _capacity(0)
	{
		swap(st);
	}

	//析構
	~Stack()
	{
		delete[] _array;
	}
private:
	int* _array;
	size_t _size;
	size_t _capacity;
};

int main()
{
	Stack s1;

	Stack s2(std::move(s1));
}

在這里插入圖片描述

默認移動賦值運算符（C++11起）

聲明形式：ClassName& operator=(ClassName&&)
作用：通過右值引用轉移資源所有權。
生成條件：同移動構造函數。
注意：需正確處理自移動賦值。

class Stack
{
public:
	//初始化
	Stack()
	{
		_array = new int[20];
	}

	Stack(const Stack& st)
	{
		_array = new int[10];
		_size = st._size;
		_capacity = st._capacity;
	}

	Stack& operator=(const Stack& st)
	{
		if (this != &st)
		{
			_array = new int[10];
			_size = st._size;
			_capacity = st._capacity;
		}

		return *this;

	}

	void swap(Stack& st)
	{
		std::swap(_array, st._array);
		std::swap(_size, st._size);
		std::swap(_capacity, st._capacity);
	}

	//移動構造函數
	Stack(Stack&& st):_array(nullptr), _size(0), _capacity(0)
	{
		swap(st);
	}

	//移動復制構造
	Stack& operator=(Stack&& st)
	{
		swap(st);

		st._array = nullptr;
		st._size = 0;
		st._capacity = 0;

		return *this;
	}

	//析構
	~Stack()
	{
		delete[] _array;
	}
private:
	int* _array;
	size_t _size;
	size_t _capacity;
};

int main()
{
	Stack s1;

	Stack s2;

	s2 = std::move(s1);
}

在C++中，前置++和后置++運算符可以通過成員函數或非成員函數的形式進行重載。兩者的主要區(qū)別在于參數列表和返回值：

前置++：增加對象的值，并返回增加后的對象引用。
后置++：首先保存當前對象的狀態(tài)，然后增加對象的值，最后返回之前保存的對象的副本。

取地址及const取地址操作符重載

在C++中，取地址操作符（&）和常量取地址操作符（const &）通常不需要顯式地重載，因為編譯器提供了默認的實現(xiàn)，它們分別返回對象或常量對象的內存地址。然而，在某些特定情況下，你可能想要自定義這些操作符的行為。

取地址操作符重載

當你重載取地址操作符時，你通常是為了改變其默認行為，例如返回一個代理對象的地址而不是原始對象的地址。不過這種情況非常少見，大多數時候并不需要這樣做。

常量取地址操作符重載

類似地，重載常量版本的取地址操作符也是為了提供特定的行為，但同樣，這并不是常見的需求。

示例代碼

盡管不常見，這里還是給出如何重載這兩種操作符的基本示例：

#include <iostream>

class MyClass {
private:
    int value;
public:
    MyClass(int val) : value(val) {}

    // 重載取地址操作符
    int* operator&() {
        std::cout << "非const取地址操作符被調用" << std::endl;
        return &value;
    }

    // 重載const取地址操作符
    const int* operator&() const {
        std::cout << "const取地址操作符被調用" << std::endl;
        return &value;
    }
};

int main() {
    MyClass obj(10);
    const MyClass constObj(20);

    int* addr = &obj;       // 調用非const版本
    const int* constAddr = &constObj; // 調用const版本

    std::cout << "*addr: " << *addr << std::endl;
    std::cout << "*constAddr: " << *constAddr << std::endl;

    return 0;
}

輸出結果

非const取地址操作符被調用
const取地址操作符被調用
*addr: 10
*constAddr: 20

在這個例子中，我們?yōu)?code>MyClass類重載了取地址操作符和常量取地址操作符。當通過非常量對象調用operator&()時，會調用非常量版本的操作符，并打印一條消息。而當通過常量對象調用operator&()時，則調用常量版本的操作符，并打印另一條不同的消息。

注意事項

謹慎使用：一般情況下，不需要也不建議重載這兩個操作符，除非有特別的需求。這是因為它們改變了標準語義，可能會導致混淆或者不可預期的行為。
保持一致性：如果你決定重載這些操作符，請確保它們的行為符合邏輯且一致，避免引入錯誤。
理解限制：需要注意的是，即使你重載了取地址操作符，也無法阻止使用內置的取地址操作來獲取對象的實際地址。例如，&obj總是可以獲得obj的實際地址，除非你完全隱藏了對象的訪問方式。

總的來說，重載取地址操作符和常量取地址操作符是一種高級技巧，適用于特定場景下的特殊需求。在大多數日常編程任務中，這種重載是不必要的。

擴展：前置++和后置++重載

重載規(guī)則

前置++只需要一個參數（即調用該運算符的對象本身），并且通常返回一個指向修改后的對象的引用。
后置++需要兩個參數：第一個是調用該運算符的對象本身，第二個是一個int類型的占位參數，用于區(qū)分前置和后置形式。后置++返回的是操作前對象的一個副本（通常是通過值返回）。

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;

class Count
{
public:
	//重載后置++
	Count operator++()
	{
		++_count;
		return *this;
	}

	//后置++
	Count operator++(int)
	{
		Count temp = *this;
		++_count;
		return temp;
	}

	int getCount() const {
		return _count;
	}
private:
	int _count = 0;
};

int main()
{
	Count myCounter;

	std::cout << "Initial count: " << myCounter.getCount() << std::endl;

	++myCounter; // 調用前置++
	std::cout << "After prefix increment: " << myCounter.getCount() << std::endl;

	Count d;
	d = myCounter++; // 調用后置++
	std::cout << "After postfix increment: " << d.getCount() << std::endl;

	return 0;
}

到此這篇關于C++六大默認成員函數的實現(xiàn)的文章就介紹到這了,更多相關C++ 默認成員函數內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

您可能感興趣的文章:

C++深入探究類與對象之對象模型與this指針使用方法
C++對象模型中只有類的非static成員以及一個指向虛函數表的指針被配置于類對象內，其他都在類對象外，在 C++ 中，每一個對象都能通過 this 指針來訪問自己的地址。this 指針是所有成員函數的隱含參數。因此，在成員函數內部，它可以用來指向調用對象
2022-04-04
Qt禁止程序多開的實現(xiàn)示例
本文主要介紹了Qt 禁止程序多開的實現(xiàn)示例,主要介紹了三種方法,文中通過示例代碼介紹的非常詳細,對大家的學習或者工作具有一定的參考學習價值,需要的朋友們下面隨著小編來一起學習學習吧
2023-09-09
C++中的重載、覆蓋、隱藏介紹
這篇文章主要介紹了C++中的重載、覆蓋、隱藏介紹,需要的朋友可以參考下
2015-04-04
C++未定義行為（undefined behavior）
對于未定義行為，C++標準沒有明確規(guī)定編譯器們應該怎么做，那么執(zhí)行的結果就是不可預料的。下面我們來詳細探討下
2017-02-02
C++中大括號的用法合集
學習C++以來還沒有總結過C++的大括號的使用方式,所以這篇文章主要來和大家介紹一下C++中大括號的用法合集,需要的小伙伴可以參考一下
2024-12-12
獲取本地網卡適配器信息具體代碼
這篇文章主要介紹了獲取本地網卡適配器信息具體代碼，有需要的朋友可以參考一下
2013-12-12
C++與C的差異分析
這篇文章主要介紹了C++與C的差異分析,非常實用,需要的朋友可以參考下
2014-08-08
VS報錯C1189及MSB3721解決方法
在使用VS進行CUDA編譯時出現(xiàn)錯誤,本文主要介紹了VS報錯C1189及MSB3721解決方法,具有一定的參考價值,感興趣的可以了解一下
2024-06-06
C語言實現(xiàn)定時器控制LED燈閃爍
這篇文章主要為大家詳細介紹了C語言實現(xiàn)定時器控制LED燈閃爍，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下
2021-05-05
c++ 結構體內存對齊基本概念及示例
這篇文章主要介紹了c++ 結構體內存對齊基本概念及示例，幫助大家更好的理解和學習c++，感興趣的朋友可以了解下
2020-12-12