- 私たちが生活の中で購入する電子製品は、基本的に出荷時の設定になっています。安全を確保するために、特定の日に使用しない場合、私たち自身の情報やデータの一部は削除されます。
-
C ++のオブジェクト指向は生命から生まれたものであり、各オブジェクトには、オブジェクトが破棄される前にデータをクリーンアップするための初期設定と設定もあります。
1.コンストラクタとデストラクタ
オブジェクトの初期化とクリーンアップも2つの非常に重要なセキュリティ問題です
オブジェクトまたは変数には初期状態がなく、その使用の結果は不明です
同様に、オブジェクトまたは変数を使用した後、時間内にクリーンアップされないと、特定のセキュリティ問題が発生します
C ++は、コンストラクタとデストラクタを使用して上記の問題を解決します。これら2つの関数は、オブジェクトの初期化とクリーンアップ作業を完了するためにコンパイラによって自動的に呼び出されます。
オブジェクトの初期化とクリーンアップはコンパイラーが強制することなので、構築と破棄を提供しない場合、コンパイラーは提供します
コンパイラーによって提供されるコンストラクターとデストラクタは、空の実装です。
-
コンストラクター：主な機能は、オブジェクトの作成時にオブジェクトのメンバープロパティに値を割り当てることです。コンストラクターはコンパイラーによって自動的に呼び出されるため、手動で呼び出す必要はありません。
-
デストラクタ：主な機能は、オブジェクトが破棄される前にシステムを自動的に呼び出して、クリーンアップ作業を実行することです。
デストラクタの実行順序は、コンストラクタの実行順序とは厳密に逆です。
コンストラクター構文：类名(){}
-
コンストラクター、戻り値も書き込みvoidもありません
-
関数名はクラス名と同じです
-
コンストラクターはパラメーターを持つことができるため、オーバーロードが発生する可能性があります
-
プログラムは、オブジェクトを呼び出すときに構造体を自動的に呼び出します。手動で呼び出す必要はなく、1回だけ呼び出されます。
デストラクタ構文： ~类名(){}
-
デストラクタ、戻り値も書き込みvoidもありません
-
関数名はクラス名と同じですが、名前の前に記号〜が付いています
-
デストラクタはパラメータを持つことができないため、オーバーロードは発生しません
-
プログラムは、オブジェクトが破棄される前にデストラクタを自動的に呼び出します。手動で呼び出す必要はなく、1回だけ呼び出されます。
#include <iostream>
using namespace std;
class Person
{
public:
//构造函数
Person()
{
cout << "Person的构造函数调用" << endl;
}
//析构函数
~Person()
{
cout << "Person的析构函数调用" << endl;
}
};
void test01()
{
Person p;
}
int main(void) {
test01();
system("pause");
return 0;
}
2.コンストラクターの分類と呼び出し
2つの分類方法：
パラメータに応じて、パラメータ構造と非パラメータ構造に分けられます。
タイプ別：通常構造とコピー構造
class Person
{
public:
//无参（默认）构造函数
Person()
{
cout << "无参构造函数!" << endl;
}
//有参构造函数
Person(int a)
{
age = a;
cout << "有参构造函数!" << endl;
}
//拷贝构造函数
Person(const Person& p)
{
age = p.age;
cout << "拷贝构造函数!" << endl;
}
//析构函数
~Person()
{
cout << "析构函数!" << endl;
}
public:
int age;
};3つの呼び出しメソッド：
ブラケット
表示方法
暗黙の変換
//2、构造函数的调用
//调用无参构造函数
void test01()
{
Person p; //调用无参构造函数
}
//调用有参的构造函数
void test02()
{
//2.1 括号法，常用
Person p1(10);
//注意1：调用无参构造函数不能加括号，如果加了编译器认为这是一个函数声明
//Person p2();
//2.2 显式法
Person p2 = Person(10);
Person p3 = Person(p2);
//Person(10)单独写就是匿名对象 当前行结束之后，马上析构
//2.3 隐式转换法
Person p4 = 10; // Person p4 = Person(10);
Person p5 = p4; // Person p5 = Person(p4);
//注意2：不能利用 拷贝构造函数 初始化匿名对象 编译器认为是对象声明
//Person p5(p4);
}test01テスト結果
test02テスト結果
注1：パラメーターなしコンストラクターを呼び出すときに括弧を追加することはできません。追加すると、コンパイラーはそれを関数宣言と見なします。
注2：コピーコンストラクターを使用して匿名オブジェクトを初期化することはできません。コンパイラーはそれをオブジェクト宣言。
3.コピーコンストラクターを呼び出すタイミング
コピーコンストラクタがC ++で呼び出される場合、通常3つの状況があります。
-
作成済みのオブジェクトを使用して、新しいオブジェクトを初期化します
-
値を関数パラメーターに値で渡す
-
ローカルオブジェクトを値で返す
（1）作成したオブジェクトを使用して新しいオブジェクトを初期化します
#include <iostream>
using namespace std;
class Person3
{
public:
Person3()
{
cout << "无参构造函数!" << endl;
mAge = 0;
}
Person3(int age)
{
cout << "有参构造函数!" << endl;
mAge = age;
}
Person3(const Person3& p)
{
cout << "拷贝构造函数!" << endl;
mAge = p.mAge;
}
//析构函数在释放内存之前调用
~Person3()
{
cout << "析构函数!" << endl;
}
public:
int mAge;
};
//1. 使用一个已经创建完毕的对象来初始化一个新对象
void test01() {
Person3 man(100); //p对象已经创建完毕
Person3 newman(man); //调用拷贝构造函数
Person3 newman2 = man; //拷贝构造
Person3 newman3;
newman3 = man; //不是调用拷贝构造函数，赋值操作
}
int main(void)
{
test01();
system("pause");
return 0;
}
（2）値の受け渡しの方法で関数パラメータに値を渡します
//2. 值传递的方式给函数参数传值
//相当于Person p1 = p;
void doWork(Person p1) {}
void test02()
{
Person p; //无参构造函数
doWork(p);
}
（3）ローカルオブジェクトを値で返す
//3. 以值方式返回局部对象
Person doWork2()
{
Person p1;
cout << (int *)&p1 << endl;
return p1; //按照p1拷贝一个对象返回
}
void test03()
{
Person p = doWork2();
cout << (int *)&p << endl;
}
4.コンストラクター呼び出しルール
デフォルトでは、C ++コンパイラは少なくとも3つの関数をクラスに追加します
1.1。デフォルトのコンストラクター（パラメーターなし、関数本体は空です）
2.2。デフォルトのデストラクタ（パラメータなし、関数本体は空です）
3.3。デフォルトのコピーコンストラクター、属性の値をコピーします
ルールを呼び出すコンストラクターは次のとおりです。
-
ユーザーがパラメーターコンストラクターを定義すると、C ++はデフォルトのパラメーターなし構文を提供しなくなりますが、デフォルトのコピー構文を提供します
-
ユーザーがコピーコンストラクターを定義した場合、c ++は他のコンストラクターを提供しません
5.ディープコピーとシャローコピー
深くて浅いコピーは、古典的なインタビューの質問であり、よくある落とし穴です
浅いコピー：簡単な割り当てコピー操作
ディープコピー：コピー操作のためにヒープ領域のスペースを再適用します
#include <iostream>
using namespace std;
class Person
{
public:
Person()
{
cout << "无参构造函数!" << endl;
}
Person(int age)
{
m_Age = age;
cout << "有参构造函数!" << endl;
}
~Person()
{
cout << "析构函数!" << endl;
}
int m_Age;
};
void test05()
{
Person p1(18);
cout << "p1的年龄:" << p1.m_Age << endl;
Person p2(p1);
cout << "p2的年龄:" << p2.m_Age << endl;
}
int main(void)
{
test05();
system("pause");
return 0;
}
ここでは、システムのデフォルトのコピーコンストラクターを呼び出します
次に、ヒープ領域の高さ属性を開き、次のようにコードを変更します。
#include <iostream>
using namespace std;
class Person
{
public:
Person()
{
cout << "无参构造函数!" << endl;
}
Person(int age,int height)
{
m_Age = age;
m_Height = new int(height);
cout << "有参构造函数!" << endl;
}
~Person()
{
if (m_Height != NULL)
{
delete m_Height;
m_Height = NULL;
}
cout << "析构函数!" << endl;
}
int m_Age;
int* m_Height;
};
void test05()
{
Person p1(18,160);
cout << "p1的年龄:" << p1.m_Age << "p1的身高:"<<*p1.m_Height<< endl;
Person p2(p1);
cout << "p2的年龄:" << p2.m_Age << "p2的身高:" << *p2.m_Height << endl;
}
int main(void)
{
test05();
system("pause");
return 0;
}次のエラーが発生しました
コンパイラが提供するコピーコンストラクタを使用すると、浅いコピーが作成されます。
p1のm_Age属性は、バイトごとにp2のm_Ageにコピーされます。
属性int * m_Heightは、ヒープ領域で開かれたスペースであり、バイトごとにコピーされます。
デストラクタが実行されると、p2が最初にデストラクタを実行します。つまり、ヒープ領域のメモリが解放されます。p1もデストラクタを実行し、この時点でヒープ領域のメモリが再び解放されます。これは不正です。操作。
これは、浅いコピー（ヒープ領域でのメモリの繰り返し解放）によって引き起こされる問題です。
浅いコピーの問題を解決するために深いコピーを使用する
#include <iostream>
using namespace std;
class Person
{
public:
Person()
{
cout << "无参构造函数!" << endl;
}
Person(int age,int height)
{
m_Age = age;
m_Height = new int(height);
cout << "有参构造函数!" << endl;
}
//自己实现拷贝构造函数 来解决浅拷贝的问题
Person(const Person& p)
{
//编译器写的
//m_Age = p.m_Age;
//m_Height = p.m_Height;
//深拷贝
m_Age = p.m_Age;
m_Height = new int(*p.m_Height);
cout << "拷贝参构造函数!" << endl;
}
~Person()
{
if (m_Height != NULL)
{
delete m_Height;
m_Height = NULL;
}
cout << "析构函数!" << endl;
}
int m_Age;
int* m_Height;
};
void test05()
{
Person p1(18,160);
cout << "p1的年龄:" << p1.m_Age << "p1的身高:"<<*p1.m_Height<< endl;
Person p2(p1);
cout << "p2的年龄:" << p2.m_Age << "p2的身高:" << *p2.m_Height << endl;
}
int main(void)
{
test05();
system("pause");
return 0;
}
概要：属性がヒープ領域で開発されている場合は、浅いコピーによって引き起こされる問題を防ぐために、独自のコピーコンストラクターを提供する必要があります。
6.初期化リスト
効果：
C ++は、プロパティを初期化するための初期化リスト構文を提供します
文法：构造函数()：属性1(值1),属性2（值2）... {}
伝統的な形
#include <iostream>
using namespace std;
class Person6
{
public:
//传统方式
Person6(int a, int b)
{
m_A = a;
m_B = b;
}
int m_A;
int m_B;
};
void test06()
{
Person6 p(10, 20);
cout << p.m_A << endl;
cout << p.m_B << endl;
}
int main(void)
{
test06();
system("pause");
return 0;
}
初期化リストを使用する
#include <iostream>
using namespace std;
class Person6
{
public:
//初始化列表
Person6(int a, int b) :m_A(a), m_B(b)
{
}
int m_A;
int m_B;
};
void test06()
{
Person6 p(10, 20);
cout << p.m_A << endl;
cout << p.m_B << endl;
}
int main(void)
{
test06();
system("pause");
return 0;
}
7.クラスメンバーとしてのクラスオブジェクト
C ++クラスのメンバーは、別のクラスのオブジェクトになることができます。このメンバーをオブジェクトメンバーと呼びます。
例えば：
class A {}
class B
{
A a；
}クラスBにはオブジェクトAがメンバーとしてあり、Aはオブジェクトメンバーです。
では、Bのオブジェクトを作成するとき、AとBの構築と破棄の順序は誰ですか？
#include <iostream>
#include <string>
using namespace std;
//手机类
class Phone
{
public:
string p_name;
Phone(string name) :p_name(name)
{
cout << "Phone 的构造函数" << endl;
}
~Phone()
{
cout << "Phone 的析构函数" << endl;
}
};
//人类
class Person7
{
public:
//m_Phone(p_Name)相当于 Phone m_Phone(p_Name)隐式转换法
Person7(string name, string p_Name) :m_Name(name), m_Phone(p_Name)
{
cout << "Person 的构造函数" << endl;
}
~Person7()
{
cout << "Person 的析构函数" << endl;
}
string m_Name;
Phone m_Phone;
};
void test07()
{
Person7 p("张三", "华为");
cout <<p.m_Name<<"拿着" <<p.m_Phone.p_name<< endl;
}
int main(void)
{
//当类中成员是其他类对象时，我们称该成员为 对象成员
//构造的顺序是 ：先调用对象成员的构造，再调用本类构造
//析构顺序与构造相反
test07();
system("pause");
return 0;
}8.静的メンバー
静的メンバーは、静的メンバーと呼ばれるメンバー変数およびメンバー関数の前にキーワードstaticを追加することです。
静的メンバーは次のように分けられます。
-
静的メンバー変数
-
すべてのオブジェクトが同じデータを共有します
-
コンパイル中にメモリを割り当てます
-
クラス内宣言、クラス外初期化
-
-
静的メンバー関数
-
すべてのオブジェクトは同じ機能を共有します
-
静的メンバー関数は静的メンバー変数にのみアクセスできます
-
（1）静的メンバー変数
#include <iostream>
using namespace std;
class Person8
{
public:
static int m_A; //静态成员变量
private:
static int m_B;
};
//类内声明，类外初始化
int Person8::m_A = 100;
int Person8::m_B = 20;
void test8()
{
Person8 p1;
cout << p1.m_A << endl;
Person8 p2;
p2.m_A = 200;
cout << p1.m_A << endl; //共享一份数据
//通过类名访问
cout << Person8::m_A << endl;
//私有权限访问不到
//cout << Person8::m_B << endl;
}
int main(void)
{
test8();
system("pause");
return 0;
}
（2）静的メンバー関数
#include <iostream>
using namespace std;
class Person9
{
public:
//静态成员函数
static void func()
{
m_A = 100;
//m_B = 10; //错误，不可以访问非静态成员变量
//因为静态成员函数不属于任何一个对象，而非静态成员变量必须有一个对象去指向，产生矛盾
cout << "void func调用" << endl;
}
//静态成员变量
static int m_A;
int m_B;
private:
static void func2()
{
cout << "void func2调用" << endl;
}
};
//静态成员变量初始化
int Person9::m_A = 10;
void test9()
{
//静态成员变量两种访问方式
//1、通过对象
Person9 p;
p.func();
//2、通过类名
Person9::func();
//Person9::func2(); //私有权限访问不到
}
int main(void)
{
test9();
system("pause");
return 0;
}
静的メンバー関数は、非静的メンバー変数にアクセスできません。静的メンバー関数はどのオブジェクトにも属していないため、非静的メンバー変数にはポイントするオブジェクトが必要であり、矛盾が生じます。