C++コアプログラミング学習記録
記事ディレクトリ
序文
学習ビデオ リンク:ダークホース プログラマーの創意工夫 | C++ チュートリアル
1. メモリパーティションモデル
二、引用
3. 機能改善
4. クラスとオブジェクト
4.1 梱包
4.2 オブジェクトの初期化とクリーンアップ
4.2.3 コピー コンストラクターを呼び出すタイミング
C++ では、通常、コピー コンストラクターが呼び出される場合は 3 つの状況があります:
すでに作成されたオブジェクトを使用して新しいオブジェクトを初期化する;
値を関数パラメーターに渡す;
ローカル オブジェクトを値で返す;
例:
#include <iostream>
using namespace std;
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;
};
void test01()
{
Person p1(18);
//如果不写拷贝构造，编译器会自动添加拷贝构造，并且做浅拷贝操作
Person p2(p1);
cout << "p2的年龄为： " << p2.age << endl;
}
void test02()
{
//如果用户提供有参构造，编译器不会提供默认构造，会提供拷贝构造
Person p1; //此时如果用户自己没有提供默认构造，会出错
Person p2(10); //用户提供的有参
Person p3(p2); //此时如果用户没有提供拷贝构造，编译器会提供
//如果用户提供拷贝构造，编译器不会提供其他构造函数
Person p4; //此时如果用户自己没有提供默认构造，会出错
Person p5(10); //此时如果用户自己没有提供有参，会出错
Person p6(p5); //用户自己提供拷贝构造
}
int main()
{
// test01();
test02();
system("pause");
return 0;
}
注意：以值传递的方式返回局部对象 此局部等于栈，会自动释放；
4.2.4 コンストラクターの呼び出し規則
#include <iostream>
using namespace std;
class Person
{
public:
//无参（默认）构造函数
Person()
{
cout << "无参构造函数!" << endl;
}
//有参构造函数
Person(int age, int height)
{
cout << "有参构造函数!" << endl;
m_age = age;
m_height = new int(height);
}
//拷贝构造函数
Person(const Person &p)
{
cout << "拷贝构造函数!" << endl;
//如果不利用深拷贝在堆区创建新内存，会导致浅拷贝带来的重复释放堆区问题
m_age = p.m_age;
// m_height = p.m_height; //编译器默认的拷贝函数
//用深拷贝解决浅拷贝重复释放堆区的问题
m_height = new int(*p.m_height);
}
//析构函数
~Person()
{
cout << "析构函数!" << endl;
if (m_height != NULL)
{
delete m_height;
m_height = NULL;//防止野指针出现
}
}
public:
int m_age;
int *m_height;
};
void test01()
{
Person p1(18, 180);
Person p2(p1);
cout << "p1的年龄： " << p1.m_age << " 身高： " << *p1.m_height << endl;
cout << "p2的年龄： " << p2.m_age << " 身高： " << *p2.m_height << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
4.3 C++ オブジェクト モデルとこのポインタ
4.3.1 メンバ変数とメンバ関数は別々に保存される
C++ では、クラス内のメンバー変数とメンバー関数は互いに干渉することなく個別に格納され、クラス内の非静的メンバー変数のみがクラス オブジェクトに属します。コード例
:
#include <iostream>
using namespace std;
//成员变量 和 成员函数 分开存储的 互不干扰
class Person
{
public:
int m_A; //非静态成员变量 属于类的对象上
static int m_B; //静态成员变量 不属于类对象上
void func() //非静态成员函数 不属于类对象上
{
}
static void func2(){
} //非静态成员函数 不属于类对象上
};
int Person::m_B = 100;
void test01()
{
Person p;
//空对象占用内存空间为：0 4 1 答：1
// C++编译器会给每一个空对象也分配一个字节的空间，为了区分空对象占内存的位置
//每个空对象也应该有一个独一无二的内存地址
cout << "size of p:" << sizeof(p) << endl;
}
void test02()
{
//只要不属于空对象，定义是啥类型就是几个字节
Person p;
cout << "size of p:" << sizeof(p) << endl;
}
int main()
{
// test01();
test02();
system("pause");
return 0;
}
注: クラスの内部が空の場合、その時点で占有しているバイトは 0 ではなく、1 である必要があります。これは、C++ コンパイラが、記憶域の場所を区別するために空のオブジェクトに記憶域バイトを自動的に割り当てるためです。エラー
:静的メンバ変数を定義した後、それを出力しようと思ったら、m_Bクラスを呼び出せないことが分かりました;
理由: 入力後にアクセス権がありませんと表示されます。最初にビデオにパブリック属性を追加しませんでしたが、追加後はpublic2 つの方法でアクセスできるようになります。
4.3.2 このポインタの概念
4.3.1 では、メンバー変数とメンバー関数が C++ で別々に格納され、各非静的メンバー関数は関数インスタンスのみを生成することがわかりました。これは、同じ型の複数のオブジェクトが 1 つのコードを共有することを意味します。
そこで問題は、このコード部分はどのオブジェクトが自分自身を呼び出すかをどのように区別するのかということです。
C++ は、特別なオブジェクト ポインターである this ポインターを提供することで、上記の問題を解決します。this ポインタは、呼び出されたメンバ関数が属するオブジェクトを指し、this ポインタは各非静的メンバ関数に暗黙的に含まれるポインタです。定義する必要はなく、直接使用できます。
this ポインタの目的:
*仮パラメータとメンバ変数が同じ名前である場合、this ポインタを使用して区別することができます。
クラスの非静的メンバ関数でオブジェクト自体を返すには、return を使用できます。この
コード例:
#include <iostream>
using namespace std;
class Person
{
private:
/* data */
public:
Person(int age)
{
// this指针，指向所调用的成员函数变量，所属的对象 防止重名
this->age = age;
}
Person &Personaddage(Person &p) //如果不带引用，则变为上几节学的拷贝函数，将会创建一个新的存储空间赋值
{
this->age += this->age;
return *this; //表示本体*this
}
int age; //演示出现重名现象，正常可以用下面形式定义成员变量
// int m_Age;
};
// 1、解决名称冲突
void test01()
{
Person p1(18);
cout << "p1的年龄是：" << p1.age << endl;
}
// 2、返回对象本身用*this
void test02()
{
Person p1(10);
Person p2(10);
//链式编程思想 与cout类似，可以无限堆加
p2.Personaddage(p1).Personaddage(p1);
cout << "p2的年龄是：" << p2.age << endl;
}
int main()
{
test01();
test02();
system("pause");
return 0;
}
注: 自身を返す場合は参照の使用方法に注意する必要があり、値で返す場合は新しいオブジェクトが作成され、コピー関数に変換されます。
4.3.3 Nullポインタアクセスメンバ関数
C++ の Null ポインターはメンバー関数を呼び出すこともできますが、this ポインターが使用されるかどうかにも注意してください。
このポインタを使用する場合は、コードの堅牢性を確保するために判断する必要があります。
#include <iostream>
using namespace std;
//空指针访问成员函数
class Person
{
private:
/* data */
public:
void showPersonName()
{
cout << "this is class name" << endl;
}
void ShowPersonAge()
{
// cout << "age=" <<m_Age << endl;
//一般默认的this->m_Age 此时指针地址若是空，对于一个空的类储存单元访问其m_Age属性 属于无中生有
//可以加
if (this == NULL)
{
return;
}
cout << "age=" << this->m_Age << endl;
}
int m_Age;
};
void test01()
{
Person *p = NULL;
//空指针，可以调用成员函数
p->ShowPersonAge();
//
p->showPersonName();
}
int main()
{
test01();
system("pause");
return 0;
}
4.3.4 const 変更メンバー関数
定数関数:
メンバー関数の後に const を追加した後、この関数を定数関数と呼びます。
定数関数ではメンバー属性を変更できません。メンバー属性宣言にキーワード mutable を追加した後でも、定数オブジェクトは
定数関数で変更できます:
オブジェクトを宣言する前に const を追加することは、そのオブジェクトが定数オブジェクトであることを意味し、
定数オブジェクトは定数関数のみを呼び出すことができます。
#include <iostream>
using namespace std;
// const修饰的成员函数、成员变量
// 常函数
class Person
{
private:
public:
// this指针的本质是一个指针常量，指针的指向是不可以修改的 但是指针指向的内存保存的数据可以修改
// 只有一个this->m_A时等于Person * const this 如果想让指针指向的值也不可以修改，需要声明常函数 -----> const Person * const this;
// ()后面的const相当于const Person * const this 第一个const 在成员函数后面加上const 相当于修饰this指针的指向，让指针指向的值也不可以修改
void showPerson() const
{
this->m_B = 100;
// this->m_A = 100;
// this = NULL; //指针不能修改指针的指向 Person * const this
}
void func()
{
}
Person()
{
}
int m_A;
mutable int m_B; //特殊变量，在const修饰的常函数之中也可也修改值的变量 加关键字 mutable
};
void test01()
{
Person p;
p.showPerson();
}
//常对象
void test02()
{
const Person p; //在对象前面加个常 变成常对象 创建常对象时 应该在类里创建构造函数否则会报错
// p.m_A = 100;//常对象不可以修改
p.m_B = 100; // m_B是特殊值，在常对象下可以修改
p.showPerson(); //常对象只能调用常函数
// p.func();//不兼容的类型限定符
}
int main()
{
test01();
test02();
system("pause");
return 0;
}
注: 各メンバー関数の this ポインター。
このポインターの必須のポインター定数は変更できませんが、ポイントされた値は変更できます。
4.4 友元
人生において、あなたの家にはリビングルーム（パブリック）とベッドルーム（プライベート）があります。
リビングルームにいるゲストは全員入ることができますが、ベッドルームはプライベートなので、あなただけが入ることができます。
ただし、仲の良いガールフレンドやゲイの友達の入場を許可することもできます。
プログラムでは、一部のプライベート属性はクラス外の特別な関数やクラスからもアクセスされる必要があるため、友人のテクノロジーを使用する必要があります。
フレンドの目的は、関数またはクラスが別のクラスのプライベート メンバーにアクセスできるようにすることです。
友達のキーワードは友達です
友達の3つの実現
- グローバルは友達として機能する
- 友達としてクラス
- メンバーが友達として機能する
4.4.1 グローバルは友達として機能する
#include <iostream>
using namespace std;
//全局函数做友元
//建筑物
class Building
{
// goodGay是Building的友元,因此可以访问其私有成员
friend void goodGay(Building *building);
public:
Building()
{
m_BedRoom = "卧室";
m_SettingRoom = "客厅";
}
private:
string m_BedRoom;
public:
string m_SettingRoom;
};
//创建一个全局函数
void goodGay(Building *building) //指针应该传一个地址
{
cout << "好基友全局函数正在访问:" << building->m_SettingRoom << endl;
cout << "好基友全局函数正在访问:" << building->m_BedRoom << endl;
}
void test01()
{
Building building;
goodGay(&building);
}
void test02()
{
}
int main()
{
test01();
test02();
system("pause");
return 0;
}
4.4.2 友達としてのクラス
#include <iostream>
using namespace std;
//类做友元
class Building; //声明一下
class goodGay
{
private:
public:
goodGay();
void vsisit();
Building *building;
};
//建筑物
class Building
{
//告诉编译器 goodGay类是Building类的友元 前者可以访问后者的私有内容
friend class goodGay;
public:
Building();
private:
string m_BedRoom;
public:
string m_SettingRoom;
};
Building::Building()
{
this->m_BedRoom = "卧室";
this->m_SettingRoom = "客厅";
}
goodGay::goodGay()
{
building = new Building; // 注意-------------------类里使用指针一定要分配一个新的内存
}
void goodGay::vsisit()
{
cout << "好基友全局函数正在访问:" << building->m_SettingRoom << endl;
cout << "好基友全局函数正在访问:" << building->m_BedRoom << endl;
}
void test01()
{
goodGay gg;
gg.vsisit();
}
void test02()
{
}
int main()
{
test01();
test02();
system("pause");
return 0;
}
知らせ：类内使用指针一定要在构造函数中用new分配一个新的内存
4.4.3 メンバーはフレンドとして機能します
#include <iostream>
using namespace std;
//成员函数做友元
class Building;
class goodGay
{
private:
/* data */
public:
goodGay();
void visit01(); //让visit01函数可以访问Building中的私有成员
void visit02(); //让visit02函数不可以访问Building中的私有成员
Building *building;
};
//指针指向所指对象的各种东西时用 -> 。
//类指向类下面的各种东西时，要用:: 。
//对象指向对象下面的各种东西时用 . 。
class Building
{
friend void goodGay::visit01(); //不带goodGay：：作用域的话代表是全局函数
private:
string m_BedRoom;
public:
Building();
string m_SetRoom;
};
//类外实现成员函数 记得使用this->
Building::Building()
{
this->m_BedRoom = "卧室";
this->m_SetRoom = "客厅";
}
goodGay::goodGay()
{
building = new Building; //创建一个Building类型的对象堆区，并且用building存储
}
void goodGay::visit01()
{
cout << "visit01正在访问 " << building->m_SetRoom << endl;
cout << "visit01正在访问 " << building->m_BedRoom << endl;
}
void goodGay::visit02()
{
cout << "visit02正在访问 " << building->m_SetRoom << endl;
// cout << "visit02正在访问 " << building->m_BedRoom << endl;
}
void test01()
{
goodGay gg;
gg.visit01();
gg.visit02();
}
void test02()
{
}
int main()
{
test01();
test02();
system("pause");
return 0;
}
/*
成员函数做友元易错点：
1.因为Goodgay类需要声明Building类变量，所以Building类必须Goodgay类之前声明（前向声明）；
2.因为Building的定义中需要将Goodgay类的成员函数声明成友元成员函数，所以Building类必须Goodgay类之后定义；
3.因为Goodgay中的构造函数需要调用Building的构造函数，所以Goodgay类中构造函数的实现必须在Building类的定义之后；
总结：
1. Building类在Goodgay类前面声明，后面定义；
2. Goodgay类定义“类内”时不实现 构造函数 和 需要friend的成员函数；
3. Goodgay在Building类定义后，“类外”实现构造函数 和 需要friend的成员函数；
*/
メンバ関数をフレンドにする場合の誤りやすい点:
1. Goodgay クラスは Building クラス変数を宣言する必要があるため、Goodgay クラスよりも前に Building クラスを宣言する必要がある (前方宣言); 2.
Building の定義で宣言する必要があるためGoodgay クラスのメンバー関数は Friend メンバー関数であるため、Building クラスは Goodgay クラスの後に定義する必要があります;
3. Goodgay のコンストラクターは Building コンストラクターを呼び出す必要があるため、Goodgay クラスのコンストラクターの実装は Goodgay クラスの後に定義する必要があります。 Building クラスの定義。
要約:
- Building クラスは Goodgay クラスの前に宣言され、後で定義されます。
- Goodgay クラスは、「クラス内」を定義するときにフレンドを必要とするコンストラクターとメンバー関数を実装しません。
- Building クラスの定義後、Goodgay は「クラス外」の友人を必要とするコンストラクターとメンバー関数を実装します。
4.5 演算子のオーバーロード
演算子のオーバーロードの概念: 既存の演算子を再定義し、異なるデータ型に適応する別の関数を追加します。
4.5.1 Plus 演算子のオーバーロード
機能: 2 つのカスタム データ型を追加する操作を実現します。
#include <iostream>
using namespace std;
// 重载之后的+只是简写, 还是得按照参数列表传值
// 加号运算符重载
// 1、成员函数重载 +号 本质运算是 Person p3 = p1.operator+(p2);
// 2、全局函数重载 +号 本质运算是 person p3 = p1.operator+(p1,p2)
class Person
{
private:
/* data */
public:
// Person operator+(Person &p)// P为值传递，无法改变实参，&p为引用传递，可以改变实参
// {
// Person temp;
// temp.m_A = this->m_A + p.m_A;
// temp.m_B = this->m_B + p.m_B;
// return temp;
// }
int m_A;
int m_B;
};
// 2、全局函数重载 +号
Person operator+(Person &p1, Person &p2) // P为值传递，无法改变实参，&p为引用传递，可以改变实参
{
Person temp;
temp.m_A = p1.m_A + p2.m_A;
temp.m_B = p1.m_B + p2.m_B;
return temp;
}
//函数重载
Person operator+(Person &p1, int num)
{
Person temp;
temp.m_A = p1.m_A + num;
temp.m_B = p1.m_B + num;
return temp;
}
void test01()
{
//这里其实写的有点麻烦 不如用括号法加上构造函数来赋值
Person p1;
p1.m_A = 10;
p1.m_B = 10;
Person p2;
p2.m_A = 10;
p2.m_B = 10;
Person p3;
p3 = p1 + p2;
Person p4;
p4 = p1 + 25;
cout << "p3.m_A=" << p3.m_A << endl;
cout << "p3.m_B=" << p3.m_B << endl;
cout << "p4.m_A=" << p4.m_A << endl;
cout << "p4.m_B=" << p4.m_B << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
要約 1: オーバーロード後の + は単なる省略表現であり、原則として、パラメーター リストに従って値を渡す必要があります。
4.5.2 左シフト演算子のオーバーロード
役割: カスタム データ型を出力できます。左シフト演算子をオーバーロードすることで、この種類の演算子
と同様の動作方法をコンパイラーに知らせます。cout<<p
#include <iostream>
using namespace std;
class Person
{
friend ostream &operator<<(ostream &out, Person &p);
private:
int m_A;
int m_B;
public:
Person(int a, int b);
// p<<cout 成员函数实现不了重载左移运算符 本质上 p.operator<<(cout) 简化表示其实是 p<< cout 并不是我们想要的cout << p;
// void operator<<(Person &p) {}
// int m_A;
// int m_B;
};
Person::Person(int a, int b)
{
this->m_A = a;
this->m_B = b;
}
//只能使用全局函数重载左移运算符
//本质 operator<<(cout,p) 简化为cout << p 注意： void operator<<(ostream &out, Person &p)仅仅实现一次 cout<<p 联想上几次课this返回对象本身实现的链式编程，一定要加引用& 否则会创建一个新的的对象
ostream &operator<<(ostream &out, Person &p) //可以把引用&cout换为&out 因为引用本身就有起别名的功能
{
out << "a:" << p.m_A << " b:" << p.m_B;
return out;
}
void test()
{
Person p1(10, 20);
cout << p1 << " hello world " << endl;//链式编程
}
int main()
{
test();
system("pause");
return 0;
}
注: メンバー関数は左シフト演算子のオーバーロードを実行できません。グローバル関数のみが左シフト演算子のオーバーロードを実行できます。
注: cout は ostream 出力ストリームに属し、チェーン プログラミングの代表は cout です
。 注: 関数が & を返す前にチェーン プログラミングを追加する必要があります。それ以外の場合は、新しいオブジェクトが作成されます
4.5.3 インクリメント演算子のオーバーロード
機能: インクリメント演算子をオーバーロードすることで、独自のプラスチック データのインクリメント前およびインクリメント後の操作を実現します。
#include <iostream>
using namespace std;
//重载递增运算符
//自定义整型
class MyInteger
{
friend ostream &operator<<(ostream &cout, const MyInteger &myint);
private:
int m_Num;
public:
MyInteger();
~MyInteger();
//重载前置++运算符
MyInteger &operator++() //返回引用是因为不想重新生成一个新的对象，链式编程思想，只对一个对象做重复操作
{
m_Num++;
return *this; //*this解引用表示自身
}
//重载后置++运算符
//此时不加引用，返回一个值是因为已经建立新对象temp，且如果返回一个引用则会使得temp变为局部对象变量，局部对象变量会再当前函数结束后自动释放掉
MyInteger operator++(int) // int代表占位参数，可以用于区分前置和后置递增
{
// 1.先记录当时结果
MyInteger temp = *this;
// 2.后进行递增
m_Num++;
// 3.最后再返回记录的结果
return temp;
}
};
MyInteger::MyInteger()
{
this->m_Num = 0;
}
MyInteger::~MyInteger()
{
}
//重载左移<<运算符
// ostream &operator<<(ostream &cout, MyInteger myint)//后置的时候不能进行链式运算
ostream &operator<<(ostream &cout, const MyInteger &myint)
{
cout << myint.m_Num;
return cout;
}
void test01()
{
MyInteger myint;
cout << ++(++myint) << endl; //直接加入操作符会提示并不存在，原因是myint是我们自定义的整型数据
cout << myint << endl;
}
// C++中产生的临时对象是不可修改的，即默认为const的
//非const引用只能绑定到与该引用同类型的对象,但是非常量对象可以绑定到const引用上，
//因此可以去掉左移重载参数的类的引用符，即ostream &operator<<(ostream &cout, MyInt myint)
//或者加上const变为常量引用，即ostream &operator<<(ostream &cout, const MyInt &myint)
//注意该两种方法一定要记得把最上面的友元修改为相同的形式，否则会报错
void test02()
{
MyInteger myint1;
cout << myint1++ << endl;
cout << myint1 << endl;
}
int main()
{
test01();
test02();
system("pause");
return 0;
}
注: 前演算子は引用符で囲む必要があり、後演算子は値を返す必要があります。
注: 前演算子のオーバーロードと後演算子のオーバーロードを区別するキーは、プレースホルダー int です。
注: ポストインクリメント エラー レポート、原則と 2 つの解決策:
C++ で生成された一時オブジェクトは変更できません。つまり、
デフォルトで const である非定数参照は、参照と同じ型のオブジェクトにのみバインドできますが、非定数オブジェクトは const 参照にバインドできるため、左
シフトパラメータを運ぶクラスの参照シンボル、つまり、ostream &operator<<(ostream &cout, MyInt myint)
または const を追加して定数参照になります。つまり、ostream &operator<<(ostream &cout, const MyInt) &myint)
これら 2 つのメソッドを覚えておく必要があることに注意してください。トップのフレンドを同じフォームに変更します。そうしないと、エラーが報告されます。
注: 3 番目のメソッドは、ポストインクリメント演算のエラー レポートを解決し、オーバーロードされた左シフト演算子関数を変更する必要がなく、ポストインクリメント演算を使用します。このメソッドは、演算子のポストインクリメント演算後の値のみを出力できますmyint1++;cout<<myint1<<out;。myint1値を出力できない
問題 レガシー: このセクションでは、チェーン プログラミングの考え方に基づいて、前置演算子と後置演算子のオーバーロードを実装し、カスタム整数パラメーターをインクリメントしますが、前置インクリメント演算のみが完了し、ポストインクリメント演算が完了しました。演算は実装されていません。能力がある場合は、このセクションでポストインクリメント演算子を再構築し、デクリメント演算のオーバーロード
を拡張してください。
#include <iostream>
using namespace std;
//重载递增运算符
//自定义整型
class MyInteger
{
friend ostream &operator<<(ostream &cout, const MyInteger &myint);
private:
int m_Num;
public:
MyInteger();
~MyInteger();
//重载前置++运算符
MyInteger &operator++()
{
m_Num++;
return *this; //*this解引用表示自身
}
//重载后置++运算符
MyInteger operator++(int) // int代表占位参数，可以用于区分前置和后置递增
{
// 1.先记录当时结果
MyInteger temp = *this;
// 2.后进行递增
m_Num++;
// 3.最后再返回记录的结果
return temp;
}
//重载前置--运算符
MyInteger operator--()
{
m_Num--;
return *this;
}
//重载后置--运算符 int 相当于占位符
MyInteger operator--(int)
{
//先记录当前这个数
MyInteger temp;
//进行--操作
m_Num--;
//返回开始记录的那个数
return temp;
}
};
MyInteger::MyInteger()
{
this->m_Num = 3;
}
MyInteger::~MyInteger()
{
}
//重载左移<<运算符
ostream &operator<<(ostream &cout, const MyInteger &myint)
{
cout << myint.m_Num;
return cout;
}
void test01()
{
MyInteger myint;
cout << ++(++myint) << endl;
cout << myint << endl;
}
void test02()
{
MyInteger myint;
cout << myint++ << endl;
cout << myint << endl;
}
void test03()
{
MyInteger myint;
cout << myint--<<endl;
cout << myint << endl;
}
void test04()
{
MyInteger myint;
cout << --myint << endl;
cout << myint << endl;
}
int main()
{
test01();
test02();
test03();
test04();
system("pause");
return 0;
}
4.5.4 代入演算子のオーバーロード
C++ コンパイラはクラスに少なくとも 4 つの関数を追加します
デフォルトのコンストラクター (パラメーターなし、関数本体は空)
デフォルトのデストラクター (パラメーターなし、関数本体は空)
デフォルトのコピー コンストラクター、属性代入の値をコピーします。operator =、クラス内に属性がある場合は
属性の値をコピーします。
ヒープ領域を指しているため、代入操作を実行するときに深いコピーと浅いコピーの問題も発生します。
#include <iostream>
using namespace std;
//赋值运算符重载
class Person
{
private:
public:
Person(int age);
~Person();
Person &operator=(Person &p)
{
//编译器提供的浅拷贝 m_Age=P.m_Age;
//应该先判断是否有属性在堆区，如果有应该先释放干净，然后再进行深拷贝
if (m_Age != NULL)
{
delete m_Age;
m_Age = NULL;
}
//深拷贝
this->m_Age = new int(*p.m_Age);
//返回对象本身
return *this; //链式编程思想
}
int *m_Age;
};
Person::Person(int age)
{
this->m_Age = new int(age); //堆区 由程序员手动开启，由程序员手动释放 因此需要加个析构韩硕
}
Person::~Person()
{
if (m_Age != NULL)
{
delete m_Age;
m_Age = NULL;
}
}
void test01()
{
Person p1(18);
Person p2(28);
Person p3(38);
p3 = p2 = p1; //赋值操作
cout << "p1岁数：" << *p1.m_Age << endl;
cout << "p2岁数：" << *p2.m_Age << endl;
cout << "p3岁数：" << *p3.m_Age << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
//是指针的值，存储的是地址。所以本质上拷贝过去的值是一个地址值。这也导致了，两个不同的指针，指向同一块儿内存。看上去像是改变了'值'，实际上只是挪了以下指针的指向而已。但是原本类里开辟的区域，它的值可以一直存在的，该多少还是多少。因此，这根本不算值拷贝
注: 2 番目の判断は、ヒープ領域のメモリを判断するのではなく、p2 のアドレスが空かどうかを判断することであるため、2 つのポインタ アドレスは同じメモリを指しているため、リファクタリングの実行中にバグが発生します。 解決策: ディープ コピーを使用して、
浅いコピーの問題を解決する
4.5.5 関係演算子のオーバーロード
役割:カスタム タイプ オブジェクトの比較演算に使用される、 「等しい」==と「等しくない」という2 つの関係演算子をオーバーロードします。！=
#include <iostream>
using namespace std;
//重载 关系运算符
class Person
{
private:
public:
Person(string name, int age)
{
m_Name = name;
m_Age = age;
}
bool operator==(Person &p)
{
if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
{
return true;
}
else
return false;
}
bool operator!=(Person &p)
{
if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
{
return false;
}
else
return true;
}
string m_Name;
int m_Age;
};
void test01()
{
Person p1("Tom", 19);
Person p2("Tom", 18);
if (p1 == p2)
{
cout << "equivalent" << endl;
}
else
{
cout << "not equivalent!!!" << endl;
}
if (p1 != p2)
{
cout << "not equivalent" << endl;
}
else
{
cout << "equivalent!!!" << endl;
}
}
int main()
{
test01();
system("pause");
return 0;
}
4.5.6 関数呼び出し演算子のオーバーロード
関数呼び出し演算子 () は、オーバーロード後の使用方法が関数呼び出しと非常に似ているため、ファンクターと呼ばれます。 機能
: ファンクターはより柔軟で変更可能です。 ここでは、出力クラス
拡張を実装するために使用されています: 匿名関数は、オーバーロードの直後にオーバーロードを使用します。関数呼び出し演算子 (宣言なし)
#include <iostream>
using namespace std;
//重载 函数调用运算符 （）
//打印输出的一个类
class MYPrint
{
private:
/* data */
public:
void operator()(string test)
{
cout << test << endl; // test不加双引号，直接输出string test
}
};
void test01()
{
MYPrint myPrint;
myPrint("hello world!"); //仿函数
}
//仿函数非常灵活，没有固定的写法
//加法类
class MYAdd
{
private:
/* data */
public:
int operator()(int a, int b)
{
return a + b;
}
};
void test02()
{
MYAdd myadd;//myadd算作起名了
int sum = myadd(100, 100);
cout << sum << endl;
//匿名函数对象
cout << MYAdd()(100, 100) << endl;
//特点当前行执行完立即被释放
}
int main()
{
test01();
test02();
system("pause");
return 0;
}
4.6 継承
継承はオブジェクト指向の 3 つの大きな特徴の 1 つです
。いくつかのクラスとクラスの間には特別な関係があります。これらのクラスを定義するとき、下位レベルのメンバーは上位レベルの共通性だけでなく、独自の特性も持ちます。
現時点では、コードの重複を減らすために継承技術の使用を検討できます。
4.6.1 継承の基本構文
継承の利点: コードの重複を減らす
継承でclass 子类 ： 继承方式 父类
は構文を使用します: サブクラスは派生クラスとも呼ばれ、
親クラスは基本クラスとも呼ばれます
。 サブクラスには 2 つの部分が含まれます。1
つの部分は親クラスからさまざまな方法で継承され、もう 1 つの部分は追加された親クラスのクラスとは異なります。
親クラスから継承した部分はサブクラスの共通性を示し、新たに追加した部分はサブクラスの個性を反映します。
#include <iostream>
using namespace std;
//继承实现
//公共页面
class BasePage
{
public:
void header()
{
cout << "首页、公开课、登录、注册...（公共头部）" << endl;
}
void footer()
{
cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
}
void left()
{
cout << "Java,Python,C++...(公共分类列表)" << endl;
}
};
//继承的好处：减少重复代码
//继承使用语法： class 子类 ： 继承方式 父类
//子类 也称为 派生类
//父类 也称为 基类
// Java页面
class Java : public BasePage //此处继承方式是public 公共继承方式
{
public:
void content()
{
cout << "JAVA学科视频" << endl;
}
};
// Python页面
class Python : public BasePage
{
public:
void content()
{
cout << "Python学科视频" << endl;
}
};
// C++页面
class CPP : public BasePage
{
public:
void content()
{
cout << "C++学科视频" << endl;
}
};
void test01()
{
// Java页面
cout << "Java下载视频页面如下： " << endl;
Java ja;
ja.header();
ja.footer();
ja.left();
ja.content();
cout << "--------------------" << endl;
// Python页面
cout << "Python下载视频页面如下： " << endl;
Python py;
py.header();
py.footer();
py.left();
py.content();
cout << "--------------------" << endl;
// C++页面
cout << "C++下载视频页面如下： " << endl;
CPP cp;
cp.header();
cp.footer();
cp.left();
cp.content();
}
int main()
{
test01();
system("pause");
return 0;
}
要約する
このシリーズは、C++ の通常の学習中にメモを記録するために使用されます。