C++:類與對象—繼承

類與對象—繼承

  • 一、繼承是什么？
  • 二、繼承定義
  • 三、基類和派生類對象賦值轉換
  • 四、繼承中的作用域
  • 五、派生類的默認成員函數
  • 六、繼承與友元
  • 七、繼承與靜態成員
  • 八、復雜的菱形繼承及菱形虛擬繼承
  • 九、繼承的總結和反思
  • 十、考察重點

一、繼承是什么？

繼承(inheritance)機制是面向對象程序設計使代碼可以復用的最重要的手段，它允許程序員在保持原有類特性的基礎上進行擴展，增加功能，這樣產生新的類，稱派生類。繼承呈現了面向對象程序設計的層次結構，體現了由簡單到復雜的認知過程。以前我們接觸的復用都是函數復用，繼承是類設計層次的復用。

#include<iostream>
using namespace std;
class Person
{
public:void Print(){cout << "name:" << _name << endl;cout << "age:" << _age << endl;}
protected:string _name = "peter"; // 姓名int _age = 18;  // 年齡
};
class Student : public Person
{
protected:int _stuid; // 學號
};class Teacher : public Person
{
protected:int _jobid; // 工號
};
int main()
{Student s;Teacher t;s.Print();t.Print();return 0;
}

繼承后父類的Person的成員（成員函數+成員變量）都會變成子類的一部分。這里體現出了Student和Teacher復用了Person的成員。下面我們使用監視窗口查看Student和Teacher對象，可以看到變量的復用。調用Print可以看到成員函數的復用。
在這里插入圖片描述

二、繼承定義

1.定義格式：下面我們看到Person是父類，也稱作基類。Student是子類，也稱作派生類。在這里插入圖片描述
2.繼承關系和訪問限定符
在這里插入圖片描述
在這里插入圖片描述
3.三種繼承方式：
在這里插入圖片描述
在這里插入圖片描述
總結：

  1. 基類private成員在派生類中無論以什么方式繼承都是不可見的。這里的不可見是指基類的私有成員還是被繼承到了派生類對象中，但是語法上限制派生類對象不管在類里面還是類外面都不能去訪問它。
  2. 基類private成員在派生類中是不能被訪問，如果基類成員不想在類外直接被訪問，但需要在派生類中能訪問，就定義為protected。可以看出保護成員限定符是因繼承才出現的。
  3. 實際上面的表格我們進行一下總結會發現，基類的私有成員在子類都是不可見。基類的其他成員在子類的訪問方式 == Min(成員在基類的訪問限定符，繼承方式)，public > protected >private。
  4. 使用關鍵字class時默認的繼承方式是private，使用struct時默認的繼承方式是public，不過最好顯示的寫出繼承方式。
  5. 在實際運用中一般使用都是public繼承，幾乎很少使用protetced/private繼承，也不提倡使用protetced/private繼承，因為protetced/private繼承下來的成員都只能在派生類的類里面使用，實際中擴展維護性不強。

三、基類和派生類對象賦值轉換

  • 派生類對象 可以賦值給 基類的對象 / 基類的指針 /基類的引用。這里有個形象的說法叫切片或者切割。寓意把派生類中父類那部分切來賦值過去。
  • 基類對象不能賦值給派生類對象。
  • 基類的指針或者引用可以通過強制類型轉換賦值給派生類的指針或者引用。但是必須是基類的指針是指向派生類對象時才是安全的。這里基類如果是多態類型，可以使用RTTI(RunTime Type Information)的dynamic_cast 來進行識別后進行安全轉換。
    在這里插入圖片描述
#include<iostream>
using namespace std;
class Person
{
protected:string _name; // 姓名string _sex;  // 性別int _age;	  // 年齡
};
class Student : public Person
{
public:int _No; // 學號
};
void Test()
{Student sobj;// 1.子類對象可以賦值給父類對象/指針/引用Person pobj = sobj;Person* pp = &sobj;Person& rp = sobj;//2.基類對象不能賦值給派生類對象//sobj = pobj;//3.基類的指針可以通過強制類型轉換賦值給派生類的指針pp = &sobj;Student * ps1 = (Student*)pp; // 這種情況轉換時可以的。ps1->_No = 10;pp = &pobj;Student* ps2 = (Student*)pp; // 這種情況轉換時雖然可以，但是會存在越界訪問的問題ps2->_No = 10;
}

注：在C++中，指針的類型轉換是編譯器認可的操作，但它不會改變指針所指向的內存區域的大小或布局。這意味著，雖然你將 pp 指針轉換為 Student* 類型，但是 pobj 的內存布局仍然保持不變。

四、繼承中的作用域

  1. 在繼承體系中基類和派生類都有獨立的作用域。
  2. 子類和父類中有同名成員，子類成員將屏蔽父類對同名成員的直接訪問，這種情況叫隱藏，也叫重定義。（在子類成員函數中，可以使用 基類::基類成員 顯示訪問）
  3. 需要注意的是如果是成員函數的隱藏，只需要函數名相同就構成隱藏。
  4. 注意在實際中在繼承體系里面最好不要定義同名的成員。
#include<iostream>
using namespace std;
// Student的_num和Person的_num構成隱藏關系，可以看出這樣代碼雖然能跑，但是非常容易混淆
class Person
{
protected:string _name = "小李子"; // 姓名int _num = 111; // 身份證號
};
class Student : public Person
{
public:void Print(){cout << " 姓名:" << _name << endl;cout << " 身份證號:" << Person::_num << endl;cout << " 學號:" << _num << endl;}
protected:int _num = 999; // 學號
};
void Test()
{Student s1;s1.Print();
};
int main()
{Test();return 0;
}

#include<iostream>
using namespace std;
// B中的fun和A中的fun不是構成重載，因為不是在同一作用域
// B中的fun和A中的fun構成隱藏，成員函數滿足函數名相同就構成隱藏。
class A
{
public:void fun(){cout << "func()" << endl;}
};
class B : public A
{
public:void fun(int i){A::fun();cout << "func(int i)->" << i << endl;}
};
void Test()
{B b;b.fun(10);
};
int main()
{Test();return 0;
}

五、派生類的默認成員函數

6個默認成員函數，“默認”的意思就是指我們不寫，編譯器會變我們自動生成一個，那么在派生類中，這幾個成員函數是如何生成的呢？

  1. 派生類的構造函數必須調用基類的構造函數初始化基類的那一部分成員。如果基類沒有默認的構造函數，則必須在派生類構造函數的初始化列表階段顯示調用。
  2. 派生類的拷貝構造函數必須調用基類的拷貝構造完成基類的拷貝初始化。
  3. 派生類的operator=必須要調用基類的operator=完成基類的復制。
  4. 派生類的析構函數會在被調用完成后自動調用基類的析構函數清理基類成員。因為這樣才能保證派生類對象先清理派生類成員再清理基類成員的順序。
  5. 派生類對象初始化先調用基類構造再調派生類構造。
  6. 派生類對象析構清理先調用派生類析構再調基類的析構。
  7. 因為后續一些場景析構函數需要構成重寫，重寫的條件之一是函數名相同。那么編譯器會對析構函數名進行特殊處理，處理成destrutor()，所以父類析構函數不加virtual的情況下，子類析構函數和父類析構函數構成隱藏關系。
    在這里插入圖片描述
    在這里插入圖片描述
#include<iostream>
using namespace std;
class Person
{
public:Person(const char* name = "peter"): _name(name){cout << "Person()" << endl;}Person(const Person& p): _name(p._name){cout << "Person(const Person& p)" << endl;}Person& operator=(const Person& p){cout << "Person operator=(const Person& p)" << endl;if (this != &p)_name = p._name;return *this;}~Person(){cout << "~Person()" << endl;}
protected:string _name; // 姓名
};
class Student : public Person
{
public:Student(const char* name, int num): Person(name), _num(num){cout << "Student()" << endl;}Student(const Student& s): Person(s), _num(s._num){cout << "Student(const Student& s)" << endl;}Student& operator = (const Student& s){cout << "Student& operator= (const Student& s)" << endl;if (this != &s){Person::operator =(s);_num = s._num;}return *this;}~Student(){cout << "~Student()" << endl;}
protected:int _num; //學號
};
int main()
{Student s1("jack", 18);Student s2(s1);Student s3("rose", 17);s1 = s3;return 0;
}

這段代碼定義了兩個類 Person 和 Student，Student 類繼承自 Person 類。每個類都有自己的構造函數、拷貝構造函數、賦值運算符重載和析構函數。

在 main 函數中創建了幾個 Student 對象，并展示了對象的創建、拷貝構造、賦值運算和析構的過程。讓我們逐步分析一下：

  1. 在創建 s1 時，輸出：
Person()
Student()

這是因為在創建 Student 對象時，首先會調用 Person 類的構造函數，然后再調用 Student 類的構造函數。

  1. 在創建 s2 時，采用了拷貝構造函數，輸出：
Person(const Person& p)
Student(const Student& s)

這是因為使用已存在的 s1 對象來初始化 s2，因此會調用 Person 類和 Student 類的拷貝構造函數。

  1. 在創建 s3 時，輸出：
Person()
Student()

與第一步相同，這是創建新對象時的構造函數調用。

  1. 在 s1 = s3; 語句中，采用了賦值運算符重載，輸出：
Person operator=(const Person& p)
Student& operator= (const Student& s)

這是因為 s1 已經存在，需要用 s3 的值來賦值給 s1，所以會調用 Person 類和 Student 類的賦值運算符重載函數。

  1. 在 main 函數結束時，所有對象的析構函數被調用，輸出：
~Student()
~Person()
~Student()
~Person()
~Student()
~Person()

在代碼中，對象 s1、s2、s3 的生命周期是相互獨立的，它們的析構函數調用順序與它們的創建順序相反。

因此，在 main 函數結束時，對象的析構函數調用順序是：

  1. s3 對象的析構函數被調用，先調用 Student 類的析構函數，然后調用 Person 類的析構函數。

  2. s2 對象的析構函數被調用，同樣先調用 Student 類的析構函數，然后調用 Person 類的析構函數。

  3. s1 對象的析構函數被調用，同樣先調用 Student 類的析構函數，然后調用 Person 類的析構函數。

所以，析構函數的調用順序是 s3 -> s2 -> s1。
這是對象生命周期結束時的析構函數調用順序。

六、繼承與友元

友元關系不能繼承，也就是說基類友元不能訪問子類私有和保護成員
在這里插入圖片描述

七、繼承與靜態成員

基類定義了static靜態成員，則整個繼承體系里面只有一個這樣的成員。無論派生出多少個子類，都只有一個static成員實例 。

#include<iostream>
#include<string>
using namespace std;
class Person
{
public:Person() { ++_count; }
protected:string _name; // 姓名
public:static int _count; // 統計人的個數。
};
int Person::_count = 0;
class Student : public Person
{
protected:int _stuNum; // 學號
};
class Graduate : public Student
{
protected:string _seminarCourse; // 研究科目
};
void TestPerson()
{Student s1;Student s2;Student s3;Graduate s4;cout << " 人數 :" << Person::_count << endl;Student::_count = 0;cout << " 人數 :" << Person::_count << endl;
}
int main()
{TestPerson();return 0;
}

在這里插入圖片描述

八、復雜的菱形繼承及菱形虛擬繼承

單繼承：一個子類只有一個直接父類時稱這個繼承關系為單繼承
在這里插入圖片描述
多繼承：一個子類有兩個或以上直接父類時稱這個繼承關系為多繼承
在這里插入圖片描述
菱形繼承：菱形繼承是多繼承的一種特殊情況
在這里插入圖片描述
菱形繼承的問題：從下面的對象成員模型構造，可以看出菱形繼承有數據冗余和二義性的問題。在Assistant的對象中Person成員會有兩份。
在這里插入圖片描述

#include<iostream>
#include<string>
using namespace std;
class Person
{
public:string _name; // 姓名
};
class Student : public Person
{
protected:int _num; //學號
};
class Teacher : public Person
{
protected:int _id; // 職工編號
};
class Assistant : public Student, public Teacher
{
protected:string _majorCourse; // 主修課程
};
int main()
{// 這樣會有二義性無法明確知道訪問的是哪一個Assistant a;//a._name = "peter";// 需要顯示指定訪問哪個父類的成員可以解決二義性問題，但是數據冗余問題無法解決a.Student::_name = "xxx";a.Teacher::_name = "yyy";return 0;
}

虛擬繼承可以解決菱形繼承的二義性和數據冗余的問題。如上面的繼承關系，在Student和Teacher的繼承Person時使用虛擬繼承，即可解決問題。需要注意的是，虛擬繼承不要在其他地方去使用。

#include<iostream>
using namespace std;
class Person
{
public:string _name; // 姓名
};
class Student : virtual public Person
{
protected:int _num; //學號
};
class Teacher : virtual public Person
{
protected:int _id; // 職工編號
};
class Assistant : public Student, public Teacher
{
protected:string _majorCourse; // 主修課程
};
int main()
{Assistant a;a._name = "peter";return 0;
}

虛擬繼承解決數據冗余和二義性的原理
為了研究虛擬繼承原理，我們給出了一個簡化的菱形繼承繼承體系，再借助內存窗口觀察對象成員的模型。

#include<iostream>
using namespace std;
class A
{
public:int _a;
};
// class B : public A
class B : virtual public A
{
public:int _b;
};
// class C : public A
class C : virtual public A
{
public:int _c;
};
class D : public B, public C
{
public:int _d;
};
int main()
{D d;d.B::_a = 1;d.C::_a = 2;d._b = 3;d._c = 4;d._d = 5;return 0;
}

下圖是菱形繼承的內存對象成員模型：這里可以看到數據冗余
在這里插入圖片描述

下圖是菱形虛擬繼承的內存對象成員模型：這里可以分析出D對象中將A放到的了對象組成的最下面，這個A同時屬于B和C，那么B和C如何去找到公共的A呢？這里是通過了B和C的兩個指針，指向的一張表。這兩個指針叫虛基表指針，這兩個表叫虛基表。虛基表中存的偏移量。通過偏移量可以找到下面的A。
在這里插入圖片描述

// 有人會有疑問為什么D中B和C部分要去找屬于自己的A？那么大家看看當下面的賦值發生時，d是不是要去找出B/C成員中的A才能賦值過去？
D d;
B b = d;
C c = d;

下面是上面的Person關系菱形虛擬繼承的原理解釋：
在這里插入圖片描述

九、繼承的總結和反思

  1. 很多人說C++語法復雜，其實多繼承就是一個體現。有了多繼承，就存在菱形繼承，有了菱形繼承就有菱形虛擬繼承，底層實現就很復雜。所以一般不建議設計出多繼承，一定不要設計出菱形繼承。否則在復雜度及性能上都有問題。
  2. 多繼承可以認為是C++的缺陷之一，很多后來的OO語言都沒有多繼承，如Java。
  3. 繼承和組合
  • public繼承是一種is-a的關系。也就是說每個派生類對象都是一個基類對象。
  • 組合是一種has-a的關系。假設B組合了A，每個B對象中都有一個A對象。
  • 優先使用對象組合，而不是類繼承 。
  • 繼承允許你根據基類的實現來定義派生類的實現。這種通過生成派生類的復用通常被稱 為白箱復用(white-boxreuse)。術語“白箱”是相對可視性而言：在繼承方式中，基類的 內部細節對子類可見 。繼承一定程度破壞了基類的封裝，基類的改變，對派生類有很 大的影響。派生類和基類間的依賴關系很強，耦合度高。
  • 對象組合是類繼承之外的另一種復用選擇。新的更復雜的功能可以通過組裝或組合對象來獲得。對象組合要求被組合的對象具有良好定義的接口。這種復用風格被稱為黑箱復 用(black-boxreuse)，因為對象的內部細節是不可見的。對象只以“黑箱”的形式出現。組合類之間沒有很強的依賴關系，耦合度低。優先使用對象組合有助于你保持每個類被 封裝。
  • 實際盡量多去用組合。組合的耦合度低，代碼維護性好。不過繼承也有用武之地的，有些關系就適合繼承那就用繼承，另外要實現多態，也必須要繼承。類之間的關系可以用 繼承，可以用組合，就用組合。
// Car和BMW Car和Benz構成is-a的關系class Car{protected:string _colour = "白色"; // 顏色string _num = "陜ABIT00"; // 車牌號};class BMW : public Car{public:void Drive() {cout << "好開-操控" << endl;}};class Benz : public Car{public:void Drive() {cout << "好坐-舒適" << endl;}};// Tire和Car構成has-a的關系class Tire{protected:string _brand = "Michelin";  // 品牌size_t _size = 17;         // 尺寸};class Car{protected:string _colour = "白色"; // 顏色string _num = "陜ABIT00"; // 車牌號Tire _t; // 輪胎};

十、考察重點

1. 什么是菱形繼承？菱形繼承的問題是什么？

菱形繼承是一種多重繼承的情況，其中一個派生類同時繼承了兩個間接基類，這兩個間接基類又共同繼承自同一個基類，形成了一個菱形的繼承結構。這種繼承結構的名稱源自于其類似菱形的圖形表示。下面是一個簡單的示意圖，說明了菱形繼承的結構：

    A/ \B   C\ /D

在這個示意圖中，類D同時繼承了類B和類C，而類B和類C又都繼承自類A。

菱形繼承的問題主要有兩個：

（1）. 二義性：由于派生類繼承了兩個具有相同基類的間接基類，可能會導致成員變量或成員函數在派生類中出現二義性。例如，如果類B和類C都定義了一個同名的成員函數，類D繼承了這兩個類，那么在類D中調用這個函數時，編譯器無法確定要調用哪一個版本，從而產生二義性。

（2）. 資源浪費：由于類D繼承了類B和類C的共同基類A，而這兩個間接基類可能都包含了類A的成員變量或方法，導致在派生類D中可能存在重復的成員變量或方法，造成資源的浪費。

為了解決菱形繼承帶來的問題，C++引入了虛繼承（virtual inheritance）的概念。通過在類之間使用虛繼承，可以確保共同基類在派生類中只有一份實例，從而解決了二義性和資源浪費的問題。

2. 什么是菱形虛擬繼承？如何解決數據冗余和二義性的

菱形虛擬繼承是 C++ 中針對菱形繼承問題提出的解決方案之一，它通過使用虛擬繼承來解決菱形繼承所帶來的數據冗余和二義性問題。在菱形虛擬繼承中，被虛擬繼承的基類的構造函數不會被執行多次，而是只執行一次。這樣，當派生類間接繼承了相同的虛基類時，這些虛基類在內存中只會有一份實例，從而解決了數據冗余的問題。同時，由于只存在一份虛基類實例，因此也消除了調用成員函數時的二義性問題。
3. 繼承和組合的區別？什么時候用繼承？什么時候用組合？
繼承和組合是面向對象編程中兩種常見的代碼重用機制，它們有不同的使用場景和特點。

  1. 繼承：

    • 繼承是一種“is-a”關系，它描述了兩個類之間的一種層次結構，子類繼承了父類的屬性和方法，并且可以添加自己的新屬性和方法。
    • 適合于在現有類的基礎上進行擴展，通過重用現有類的代碼來實現新類的功能。
    • 通常用于描述一種分類或分類的關系，子類是父類的特例，具有更具體的特征或行為。
    • 適用于需要實現代碼的重用和擴展的情況。

  2. 組合：

    • 組合是一種“has-a”關系，它描述了兩個類之間的一種包含關系，一個類包含另一個類的實例作為其成員變量。
    • 適合于描述一種包含關系，其中一個類包含另一個類的實例，并且通過這種組合來實現更復雜的功能。
    • 通常用于描述一種組合或擁有關系，其中一個類包含了另一個類的實例作為其一部分。
    • 適用于需要將不同的類組合在一起實現某個功能的情況，而不是通過繼承來實現。

在選擇繼承還是組合時，可以考慮以下幾點：

  • 代碼重用性：如果需要重用現有類的代碼并擴展其功能，則可以選擇繼承。如果只是需要利用現有類的功能而不需要擴展其功能，則可以選擇組合。

  • 耦合性：繼承會增加類之間的耦合性，子類與父類之間存在較強的依賴關系，而組合可以降低耦合性，類之間的關系更靈活。

  • 設計靈活性：組合比繼承更靈活，因為可以隨時更改組合關系，而不會影響類的結構。繼承則更加靜態，子類的結構受限于父類的定義。

綜上所述，當需要實現一種分類或分類的關系，并且需要重用現有類的代碼來擴展新類的功能時，可以選擇繼承。當需要實現一種包含關系，并且不需要擴展現有類的功能時，可以選擇組合。

本文來自互聯網用戶投稿，該文觀點僅代表作者本人，不代表本站立場。本站僅提供信息存儲空間服務，不擁有所有權，不承擔相關法律責任。
如若轉載，請注明出處：http://www.pswp.cn/web/10434.shtml
繁體地址，請注明出處：http://hk.pswp.cn/web/10434.shtml
英文地址，請注明出處：http://en.pswp.cn/web/10434.shtml

如若內容造成侵權/違法違規/事實不符，請聯系多彩編程網進行投訴反饋email:809451989@qq.com，一經查實，立即刪除！

相關文章

知識付費系統需要哪些資質要求,教育機構教務工作計劃內容有哪些？

知識付費系統需要哪些資質要求,教育機構教務工作計劃內容有哪些？

每個培訓教育機構都是由很多人員組成&#xff0c;作為教育機構&#xff0c;老師不必須&#xff0c;是必不可少的&#xff0c;但是除了老師之外還得配備一定數量的銷售人員和教務工作者&#xff0c;教務老師其實也就是搞后勤的&#xff0c;但是是必須的&#xff0c;那么教育機構…
閱讀更多...
Java的時間類

Java的時間類

1. 日期類 1.1 第一代日期類 1) Date: 精確到毫秒&#xff0c;代表特定的瞬間 2) SimpleDateFormat: 格式和解析日期的類 SimpleDateFormat 格式化和解析日期的具體類。它允許進行格式化(日期-→>文本)、解析(文本->日期)和規范化. import java.text.ParseExce…
閱讀更多...
Java基礎（27）Web應用中web.xml文件中可以配置哪些內容

Java基礎（27）Web應用中web.xml文件中可以配置哪些內容

在Java Web應用中&#xff0c;web.xml文件&#xff08;也被稱為部署描述符&#xff09;是一個核心的配置文件&#xff0c;它位于應用的WEB-INF目錄下。web.xml文件中可以配置多種不同的組件和參數&#xff0c;它們用來定義和調整應用的行為。以下是一些web.xml中可以配置的內容…
閱讀更多...
Web3 Tools - 助記詞生成（完整代碼）

Web3 Tools - 助記詞生成（完整代碼）

工具介紹 Web3Tools - 助記詞生成 完整代碼 代碼路徑 import React, { useState } from react; import Grid from mui/material/Grid; import Paper from mui/material/Paper; import Typography from mui/material/Typography; import Button from mui/material/Button; i…
閱讀更多...
接口自動化測試很難掌握嗎？

接口自動化測試很難掌握嗎？

一. 什么是接口測試 接口測試是一種軟件測試方法&#xff0c;用于驗證不同軟件組件之間的通信接口是否按預期工作。在接口測試中&#xff0c;測試人員會發送請求并檢查接收到的響應&#xff0c;以確保接口在不同場景下都能正常工作。 就工具而言&#xff0c;常見的測試工具有…
閱讀更多...
AI+招聘：ATS招聘系統讓HR簡歷篩選精準度達95%！

AI+招聘：ATS招聘系統讓HR簡歷篩選精準度達95%！

一提起招聘過程&#xff0c;許多HR就會想到那堆疊如山的簡歷、讓人眼花繚亂的招聘網站以及瑣碎繁復的手動數據錄入。據統計&#xff0c;平均每位HR每年要處理數百甚至上千份簡歷&#xff0c;耗費大量精力在初級篩選和跟進上。 　　市場調查機構近日發布的一份報告顯示&#xff…
閱讀更多...
【深度學習】YOLO源碼中的mAP計算代碼的理解筆記（大部分代碼逐行+基礎解釋）

【深度學習】YOLO源碼中的mAP計算代碼的理解筆記（大部分代碼逐行+基礎解釋）

提示&#xff1a;本篇博客是在閱讀了YOLO源碼中的mAP計算方法的代碼后加上官方解釋以及自己的debug調試理解每一步是怎么操作的。由于是大部分代碼進行了逐行解釋&#xff0c;所以篇幅過長。 文章目錄 前言一、輸入格式處理1.1 轉換公式二、init&#xff1a;初始化2.1 iouv2.2 …
閱讀更多...
AND Sorting題解

AND Sorting題解

AND Sorting題解 AND Sorting 詳細 題解（）題目原意解題思路這是代碼??ZZZB. AND Sorting(我也是有底線的）AND Sorting 詳細 題解（） 洛谷 原題，CF 原題 洛谷 AC記錄，CF AC記錄 題目原意 給你一個由從 0 0 0 到 n ? 1 n-1 n?1 的整數組成的排列 p p p (每個整數都…
閱讀更多...
如何在沒有頭文件的情況下調用動態庫的類的私有成員函數

如何在沒有頭文件的情況下調用動態庫的類的私有成員函數

如何在沒有頭文件的情況下調用動態庫的類成員函數 編寫一個不存在虛函數的類測試代碼 _ZN6CClass4showEv如何獲取調用 源代碼 https://github.com/TonyBeen/study/tree/master/dlopen 編寫一個不存在虛函數的類 // class.h #pragma onceclass CClass { public:CClass();~CCla…
閱讀更多...
【Leetcode每日一題】 綜合練習 - 電話號碼的字母組合（難度??）（75）

【Leetcode每日一題】 綜合練習 - 電話號碼的字母組合（難度??）（75）

1. 題目解析 題目鏈接&#xff1a;電話號碼的字母組合 這個問題的理解其實相當簡單&#xff0c;只需看一下示例&#xff0c;基本就能明白其含義了。 2.算法原理 算法設計思路 在解決這類問題時&#xff0c;我們需要認識到每個位置上的數字對應的字符集合是相互獨立的&#…
閱讀更多...
什么是翹尾因素

什么是翹尾因素

在有關CPI 的分析文章和新聞稿件中&#xff0c;經常會出現“翹尾因素”或“翹尾影響” 等詞匯&#xff0c;這是分析同比價格指數變動幅度時所特有的概念。那么什么是“翹尾因素” 或“翹尾影響”呢&#xff1f; 一、什么是翹尾因素 “翹尾因素”是指上年價格上漲&#xff08;…
閱讀更多...
使用scrollIntoView滾動元素到可視區域

使用scrollIntoView滾動元素到可視區域

1. 實現效果 點擊頂部標簽欄&#xff0c;讓對應的內容出現在可視區域&#xff1a; 2. scrollIntoView () scrollIntoView 是一個內置的 JavaScript 方法&#xff0c;用于將元素滾動到視口可見的位置。它通常用于用戶界面中&#xff0c;以便用戶能輕松看到特定的元素。此方…
閱讀更多...
perf 中的 cpu-cycles event 介紹

perf 中的 cpu-cycles event 介紹

perf 中的 cpu-cycles event 介紹 cycles簡介 cycles事件記錄處理器核心執行的時鐘周期數。每個時鐘周期代表處理器內部時鐘振蕩器的一個周期。這個事件通常用于衡量處理器的執行速度&#xff0c;因為它直接反映了指令執行所需的時間。一個較高的cycles計數可能意味著代碼執行…
閱讀更多...
JavaScript中指定大小分割數組的一種實現

JavaScript中指定大小分割數組的一種實現

今天分享一個使用JavaScript分割數組為多個自數組的方法實現。我使用它的場景如下&#xff1a; 給定一個數組 arr 和指定大小 fixed&#xff1a; const arr [{id: 1,name: name1},{id: 2,name: name2},{id: 3,name: name3},{id: 4,name: name4},{id: 5,name: name5},{id: 6,…
閱讀更多...
2024版本idea集成SpringBoot + Ai 手寫一個chatgpt 【推薦】

2024版本idea集成SpringBoot + Ai 手寫一個chatgpt 【推薦】

題目&#xff1a;SpringBoot OpenAi 在這里獲取key和url&#xff1a;獲取免費key base-url為這兩個&#xff1a; 話不多說直接來&#xff01; 一、簡介 Spring AI 是 AI 工程的應用框架。其目標是將 Spring 生態系統設計原則&#xff08;如可移植性和模塊化設計&#xff…
閱讀更多...
暗區突圍pc資格 暗區突圍pc端測試資格獲取

暗區突圍pc資格 暗區突圍pc端測試資格獲取

《暗區突圍》的誕生&#xff0c;仿佛在游戲界投下了一枚深水炸彈&#xff0c;它不僅僅是射擊游戲的新標桿&#xff0c;更是對玩家策略思維、生存直覺與團隊協作能力的一次全面考驗。在這個精心構建的虛擬戰場中&#xff0c;每一次踏入暗區&#xff0c;都是對未知的探索&#xf…
閱讀更多...
【練習4】

【練習4】

1.兩數之和 暴力&#xff1a; class Solution { public:vector<int> twoSum(vector<int>& nums, int target) {int n nums.size();vector<int> res(2, -1); // 初始化結果為-1for (int i 0; i < n; i) {int temp nums[i];for (int j i 1; j <…
閱讀更多...
Python 技巧：滿意的逗號放置

Python 技巧：滿意的逗號放置

當你在 Python 中添加或刪除列表、字典或集合中的項目時&#xff0c;記住總是將所有行結尾加一個逗號。這是一個非常有用的技巧&#xff0c;可以幫助你避免一些常見的問題。 不確定我所說的什么&#xff1f;讓我給你一個快速示例。假設你在代碼中有一個名單列表&#xff1a; …
閱讀更多...
銀行家算法簡易實現

銀行家算法簡易實現

這里寫目錄標題 實驗要求內容代碼main.cppmyfunc.hmyfunc.cpp 運行結果與分析 實驗要求 程序可以針對不同進程的請求進行判斷&#xff0c;并決定是否滿足其需求。算法程序需要設計合理的數據結構&#xff0c;對資源情況、進程相關數據進行存儲。 內容 隨機生成數據, 并校驗數據…
閱讀更多...
做視頻號小店，怎么找達人合作？這里有詳細講解

做視頻號小店，怎么找達人合作？這里有詳細講解

大家好&#xff0c;我是電商笨笨熊 做視頻號小店是沒有自然流量的&#xff0c;這點剛入駐的新玩家還不清楚&#xff1b; 因此很多老電商玩家們還想著繼續拿其他平臺動銷自然流的玩法去做視頻號&#xff1b; 只能說這種方式在視頻號是完全行不通的&#xff0c;當下想要推廣售…
閱讀更多...
最新文章

Copyright @ 2022~2023