??類(lèi)和對(duì)象(下篇)
??【本節(jié)目標(biāo)】
??1. 再談構(gòu)造函數(shù)
??2. Static成員
??3. 友元
??4. 內(nèi)部類(lèi)
??5.匿名對(duì)象
??6.拷貝對(duì)象時(shí)的一些編譯器優(yōu)化
??7. 再次理解類(lèi)和對(duì)象
??1.再談構(gòu)造函數(shù)
??1.1 構(gòu)造函數(shù)體賦值
在創(chuàng)建對(duì)象時(shí)，編譯器通過(guò)調(diào)用構(gòu)造函數(shù)，給對(duì)象中各個(gè)成員變量一個(gè)合適的初始值
class Date
{
public:
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
??雖然上述構(gòu)造函數(shù)調(diào)用之后，對(duì)象中已經(jīng)有了一個(gè)初始值，但是不能將其稱(chēng)為對(duì)對(duì)象中成員變量的初始化，構(gòu)造函數(shù)體中的語(yǔ)句只能將其稱(chēng)為賦初值，而不能稱(chēng)作初始化。因?yàn)槌跏蓟荒艹跏蓟淮?，而?gòu)造函數(shù)體內(nèi)可以多次賦值
??1.2 初始化列表
初始化列表：以一個(gè)冒號(hào)開(kāi)始，接著是一個(gè)以逗號(hào)分隔的數(shù)據(jù)成員列表，每個(gè)"成員變量"后面跟一個(gè)放在括號(hào)中的初始值或表達(dá)式
class Date
{
public:
Date(int year, int month, int day)
: _year(year)
, _month(month)
, _day(day)
{}
private:
int _year;
int _month;
int _day;
};
【注意】
??1. 每個(gè)成員變量在初始化列表中只能出現(xiàn)一次(初始化只能初始化一次)
??2. 類(lèi)中包含以下成員，必須放在初始化列表位置進(jìn)行初始化：
??引用成員變量 const成員變量 自定義類(lèi)型成員(且該類(lèi)沒(méi)有默認(rèn)構(gòu)造函數(shù)時(shí))
class A
{
public:
A(int a)
:_a(a)
{}
private:
int _a;
};
class B
{
public:
B(int a, int ref)
:_aobj(a)
,_ref(ref)
,_n(10)
{}
private:
A _aobj; // 沒(méi)有默認(rèn)構(gòu)造函數(shù)
int& _ref; // 引用
const int _n; // const
};
??3. 盡量使用初始化列表初始化，因?yàn)椴还苣闶欠袷褂贸跏蓟斜?，?duì)于自定義類(lèi)型成員變量，一定會(huì)先使用初始化列表初始化
class Time
{
public:
Time(int hour = 0)
:_hour(hour)
{
cout << "Time()" << endl;
}
private:
int _hour;
};
class Date
{
public:
Date(int day)
{}
private:
int _day;
Time _t;
};
int main()
{
Date d(1);
}
??4. 成員變量在類(lèi)中聲明次序就是其在初始化列表中的初始化順序，與其在初始化列表中的先后次序無(wú)關(guān)
class A
{
public:
A(int a)
:_a1(a)
,_a2(_a1)
{}
void Print() {
cout<<_a1<<" "<<_a2<<endl;
}
private:
int _a2;
int _a1;
};
int main() {
A aa(1);
aa.Print();
} A
. 輸出1 1
B.程序崩潰
C.編譯不通過(guò)
D.輸出1 隨機(jī)值
在上篇文章已經(jīng)解釋過(guò)了
??1.3 explicit關(guān)鍵字
??構(gòu)造函數(shù)不僅可以構(gòu)造與初始化對(duì)象，對(duì)于單個(gè)參數(shù)或者除第一個(gè)參數(shù)無(wú)默認(rèn)值其余均有默認(rèn)值的構(gòu)造函數(shù)，還具有類(lèi)型轉(zhuǎn)換的作用
public:
上述代碼可讀性不是很好，用explicit修飾構(gòu)造函數(shù)，將會(huì)禁止構(gòu)造函數(shù)的隱式轉(zhuǎn)換
// 1. 單參構(gòu)造函數(shù)，沒(méi)有使用explicit修飾，具有類(lèi)型轉(zhuǎn)換作用
// explicit修飾構(gòu)造函數(shù)，禁止類(lèi)型轉(zhuǎn)換---explicit去掉之后，代碼可以通過(guò)編譯
explicit Date(int year)
:_year(year)
{}
/*
// 2. 雖然有多個(gè)參數(shù)，但是創(chuàng)建對(duì)象時(shí)后兩個(gè)參數(shù)可以不傳遞，沒(méi)有使用explicit修飾，具
有類(lèi)型轉(zhuǎn)換作用
// explicit修飾構(gòu)造函數(shù)，禁止類(lèi)型轉(zhuǎn)換
explicit Date(int year, int month = 1, int day = 1)
: _year(year)
, _month(month)
, _day(day)
{}
*/
Date& operator=(const Date& d)
{
if (this != &d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
return *this;
}
private:
int _year;
int _month;
int _day;
};
void Test()
{
Date d1(2022);
// 用一個(gè)整形變量給日期類(lèi)型對(duì)象賦值
// 實(shí)際編譯器背后會(huì)用2023構(gòu)造一個(gè)無(wú)名對(duì)象，最后用無(wú)名對(duì)象給d1對(duì)象進(jìn)行賦值
d1 = 2023;
// 將1屏蔽掉，2放開(kāi)時(shí)則編譯失敗，因?yàn)閑xplicit修飾構(gòu)造函數(shù)，禁止了單參構(gòu)造函數(shù)類(lèi)型轉(zhuǎn)
換的作用
}
上述代碼可讀性不是很好，用explicit修飾構(gòu)造函數(shù)，將會(huì)禁止構(gòu)造函數(shù)的隱式轉(zhuǎn)換
??2.static成員
2.1 概念
聲明為static的類(lèi)成員稱(chēng)為類(lèi)的靜態(tài)成員，用static修飾的成員變量，稱(chēng)之為靜態(tài)成員變量；用static修飾的成員函數(shù)，稱(chēng)之為靜態(tài)成員函數(shù)。靜態(tài)成員變量一定要在類(lèi)外進(jìn)行初始化
//class A
//{
//public:
// A() { ++count; }
// A(const A& t) { ++count; }
// ~A() {
// cout << "~A()" << endl;
// }
//
// // 靜態(tài)成員函數(shù)，特點(diǎn)：沒(méi)有this指針
// static int GetCount()
// {
// return count;
// }
//
//private:
// // 聲明
// static int count;
// int _a = 0;
//};
//
定義
//int A::count = 0;
//
//A func()
//{
// A aa;
// return aa;
//}
//
//int main()
//{
// //A::count++;
//
// //cout << sizeof(A) << endl;
//
// //A aa;
// func();
// func();
// func();
//
//
// //A::count++;
//
// // 公有
// // 屬于整個(gè)類(lèi)，屬于這個(gè)類(lèi)所有對(duì)象
// // 受訪問(wèn)限定符限制
// //cout << A::count << endl;
// //cout << aa.count << endl;
//
// // A aa;有名對(duì)象
// //A aa; //為了調(diào)用而創(chuàng)建的，所以要-1
// //cout << aa.GetCount()-1 << endl;
//
//
// // A() 這種寫(xiě)法叫做匿名對(duì)象，生命周期只在這一行
// //cout << A().GetCount() - 1 << endl;
//
// cout << A::GetCount() << endl;
// //cout << A().GetCount() << endl;
//
// // 總結(jié)一下：靜態(tài)成員函數(shù)和靜態(tài)成員變量，本質(zhì)受限制的全局變量和全局函數(shù)
// // 專(zhuān)屬這個(gè)類(lèi)，受類(lèi)域和訪問(wèn)限定符的限制
//
??2.2 特性
??1. 靜態(tài)成員為所有類(lèi)對(duì)象所共享，不屬于某個(gè)具體的對(duì)象，存放在靜態(tài)區(qū)
??2. 靜態(tài)成員變量必須在類(lèi)外定義，定義時(shí)不添加static關(guān)鍵字，類(lèi)中只是聲明
??3. 類(lèi)靜態(tài)成員即可用 類(lèi)名::靜態(tài)成員 或者 對(duì)象.靜態(tài)成員 來(lái)訪問(wèn)
??4. 靜態(tài)成員函數(shù)沒(méi)有隱藏的this指針，不能訪問(wèn)任何非靜態(tài)成員
??5. 靜態(tài)成員也是類(lèi)的成員，受public、protected、private 訪問(wèn)限定符的限制
下面我們來(lái)寫(xiě)一道?？途W(wǎng)的題目 運(yùn)用到了static的知識(shí)
題目鏈接
??3. 友元
友元提供了一種突破封裝的方式，有時(shí)提供了便利。但是友元會(huì)增加耦合度，破壞了封裝，所以友元不宜多用
友元分為：友元函數(shù)和友元類(lèi)
??3.1 友元函數(shù)
問(wèn)題：現(xiàn)在嘗試去重載operator<<，然后發(fā)現(xiàn)沒(méi)辦法將operator<<重載成成員函數(shù)。因?yàn)閏out的輸出流對(duì)象和隱含的this指針在搶占第一個(gè)參數(shù)的位置。this指針默認(rèn)是第一個(gè)參數(shù)也就是左操作數(shù)了。但是實(shí)際使用中cout需要是第一個(gè)形參對(duì)象，才能正常使用。所以要將operator<<重載成全局函數(shù)。但又會(huì)導(dǎo)致類(lèi)外沒(méi)辦法訪問(wèn)成員，此時(shí)就需要友元來(lái)解決。operator>>同理
class Date
{
public:
Date(int year, int month, int day)
: _year(year)
, _month(month)
, _day(day)
{}
// d1 << cout; -> d1.operator<<(&d1, cout); 不符合常規(guī)調(diào)用
// 因?yàn)槌蓡T函數(shù)第一個(gè)參數(shù)一定是隱藏的this，所以d1必須放在<<的左側(cè)
ostream& operator<<(ostream& _cout)
{
_cout << _year << "-" << _month << "-" << _day << endl;
return _cout;
}
private:
int _year;
int _month;
int _day;
};
??友元函數(shù)可以直接訪問(wèn)類(lèi)的私有成員，它是定義在類(lèi)外部的普通函數(shù)，不屬于任何類(lèi)，但需要在類(lèi)的內(nèi)部聲明，聲明時(shí)需要加friend關(guān)鍵字
class Date
{
friend ostream& operator<<(ostream& _cout, const Date& d);
friend istream& operator>>(istream& _cin, Date& d);
public:
Date(int year = 1900, int month = 1, int day = 1)
: _year(year)
, _month(month)
, _day(day)
{}
private:
int _year;
int _month;
int _day;
};
ostream& operator<<(ostream& _cout, const Date& d)
{
_cout << d._year << "-" << d._month << "-" << d._day;
return _cout;
}
istream& operator>>(istream& _cin, Date& d)
{
_cin >> d._year;
_cin >> d._month;
_cin >> d._day;
return _cin;
}
int main()
{
Date d;
cin >> d;
cout << d << endl;
return 0;
}
??友元函數(shù)可訪問(wèn)類(lèi)的私有和保護(hù)成員，但不是類(lèi)的成員函數(shù)
??友元函數(shù)不能用const修飾
??友元函數(shù)可以在類(lèi)定義的任何地方聲明，不受類(lèi)訪問(wèn)限定符限制
??一個(gè)函數(shù)可以是多個(gè)類(lèi)的友元函數(shù)
??友元函數(shù)的調(diào)用與普通函數(shù)的調(diào)用原理相同
??3.2 友元類(lèi)
友元類(lèi)的所有成員函數(shù)都可以是另一個(gè)類(lèi)的友元函數(shù)，都可以訪問(wèn)另一個(gè)類(lèi)中的非公有成員
友元關(guān)系是單向的，不具有交換性
比如上述Time類(lèi)和Date類(lèi)，在Time類(lèi)中聲明Date類(lèi)為其友元類(lèi)，那么可以在Date類(lèi)中直接訪問(wèn)Time類(lèi)的私有成員變量，但想在Time類(lèi)中訪問(wèn)Date類(lèi)中私有的成員變量則不行 友元關(guān)系不能傳遞
如果C是B的友元， B是A的友元，則不能說(shuō)明C時(shí)A的友元
友元關(guān)系不能繼承，在繼承位置再給大家詳細(xì)介紹
class Time
{
friend class Date; // 聲明日期類(lèi)為時(shí)間類(lèi)的友元類(lèi)，則在日期類(lèi)中就直接訪問(wèn)Time類(lèi)
中的私有成員變量
public:
Time(int hour = 0, int minute = 0, int second = 0)
: _hour(hour)
, _minute(minute)
, _second(second)
{}
private:
int _hour;
int _minute;
int _second;
};
class Date
{
public:
Date(int year = 1900, int month = 1, int day = 1)
: _year(year)
, _month(month)
, _day(day)
{}
void SetTimeOfDate(int hour, int minute, int second)
{
// 直接訪問(wèn)時(shí)間類(lèi)私有的成員變量
_t._hour = hour;
_t._minute = minute;
_t._second = second;
}
private:
int _year;
int _month;
int _day;
Time _t;
};
//class A
//{
//private:
// int h;
//public:
// // A和B關(guān)系
// // B就是一個(gè)普通類(lèi)，只是受A的類(lèi)域和訪問(wèn)限定符限制,本質(zhì)相當(dāng)于被封裝了一下
//
// // B天生就是A的友元
// class B
// {
// public:
// void func()
// {
// A aa;
// // B天生就是A的友元
// aa.h++;
// }
// private:
// int _b;
// };
//};
//
//int main()
//{
// cout << sizeof(A) << endl;
//
// A aa;
// A::B bb;
//
// return 0;
//}
//class A
//{
//public:
// //explicit A(int a)
// A(int a)
// :_a(a)
// {}
//
// /*A(int* p)
// {}*/
//
// int _a = 0;
//};
//
//class Date
//{
//public:
// Date(int year = 1, int month = 1, int day = 1)
// : _year(year)
// , _month(month)
// , _day(day)
// {}
//
//private:
// int _year;
// int _month;
// int _day;
//};
//
//int main()
//{
// //A aa1(1);
// //A aa2(2);
//
// // 內(nèi)置類(lèi)型對(duì)象 隱式轉(zhuǎn)換成自定義類(lèi)型對(duì)象
// // 能支持這個(gè)轉(zhuǎn)換，是有A的int單參數(shù)構(gòu)造函數(shù)(支持傳一個(gè)參數(shù)多參數(shù)帶缺省也可以)支持
// // 不想讓隱式類(lèi)型轉(zhuǎn)換發(fā)生，構(gòu)造函數(shù)加explicit
// //A aa3 = 3;
// //const A& ra = 3;
//
// //int* p = NULL;
// //A aa4 = p;
//
// // 內(nèi)置類(lèi)型 整形和浮點(diǎn) 隱式互相轉(zhuǎn)
// int i = 0;
// double d = i;
// const double& r = i;
//
// Date d1(2023, 11, 2);
// Date d2 = (2023, 11, 3); // 等價(jià)于 Date d2 = 3;
// Date d3 = 2023;
//
// // C++11
// Date d4 = { 2023, 11, 2 };
// const Date& d5 = { 2023, 11, 2 };
//
// list<A> lt;
// //void push_back(const A& aa);
// A aa1(1);
// lt.push_back(aa1);
// lt.push_back(A(2));
// lt.push_back(3);
//
// list<Date> lt1;
// Date d6(2023, 11, 2);
// lt1.push_back(d6);
//
// lt1.push_back(Date(2023, 11, 2));
// lt1.push_back({ 2023, 11, 2 });
//
// return 0;
//}
??4. 內(nèi)部類(lèi)
概念：如果一個(gè)類(lèi)定義在另一個(gè)類(lèi)的內(nèi)部，這個(gè)內(nèi)部類(lèi)就叫做內(nèi)部類(lèi)。內(nèi)部類(lèi)是一個(gè)獨(dú)立的類(lèi)，它不屬于外部類(lèi)，更不能通過(guò)外部類(lèi)的對(duì)象去訪問(wèn)內(nèi)部類(lèi)的成員。外部類(lèi)對(duì)內(nèi)部類(lèi)沒(méi)有任何優(yōu)越的訪問(wèn)權(quán)限
注意：內(nèi)部類(lèi)就是外部類(lèi)的友元類(lèi)，參見(jiàn)友元類(lèi)的定義，內(nèi)部類(lèi)可以通過(guò)外部類(lèi)的對(duì)象參數(shù)來(lái)訪問(wèn)外部類(lèi)中的所有成員。但是外部類(lèi)不是內(nèi)部類(lèi)的友元
特性：
??1. 內(nèi)部類(lèi)可以定義在外部類(lèi)的public、protected、private都是可以的
?? 2. 注意內(nèi)部類(lèi)可以直接訪問(wèn)外部類(lèi)中的static成員，不需要外部類(lèi)的對(duì)象/類(lèi)名
?? 3. sizeof(外部類(lèi))=外部類(lèi)，和內(nèi)部類(lèi)沒(méi)有任何關(guān)系
class A
{
private:
static int k;
int h;
public:
class B // B天生就是A的友元
{
public:
void foo(const A& a)
{
cout << k << endl;//OK
cout << a.h << endl;//OK
}
};
};
int A::k = 1;
int main()
{
A::B b;
b.foo(A());
return 0;
}
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A(int a)" << endl;
??5.匿名對(duì)象
匿名對(duì)象我們?cè)谟言瘮?shù)和友元類(lèi)已經(jīng)提到過(guò)了一些 具體是在vector和list那里將有名和匿名還是正常的拷貝構(gòu)造和構(gòu)造的差異性做了對(duì)比文章來(lái)源：http://www.zghlxwxcb.cn/news/detail-810904.html
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A(int a)" << endl;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a;
};
class Solution {
public:
int Sum_Solution(int n) {
//...
return n;
}
};
int main()
{
A aa1;
// 不能這么定義對(duì)象，因?yàn)榫幾g器無(wú)法識(shí)別下面是一個(gè)函數(shù)聲明，還是對(duì)象定義
//A aa1();
// 但是我們可以這么定義匿名對(duì)象，匿名對(duì)象的特點(diǎn)不用取名字，
// 但是他的生命周期只有這一行，我們可以看到下一行他就會(huì)自動(dòng)調(diào)用析構(gòu)函數(shù)
A();
A aa2(2);
// 匿名對(duì)象在這樣場(chǎng)景下就很好用，當(dāng)然還有一些其他使用場(chǎng)景，這個(gè)我們以后遇到了再說(shuō)
Solution().Sum_Solution(10);
return 0;
}
??6.拷貝對(duì)象時(shí)的一些編譯器優(yōu)化
// 擴(kuò)展：一些構(gòu)造時(shí)的優(yōu)化，不同的編譯器可能會(huì)不同（了解一下）
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A(int a)" << endl;
}
A(const A& aa)
:_a(aa._a)
{
cout << "A(const A& aa)" << endl;
}
A& operator=(const A& aa)
{
cout << "A& operator=(const A& aa)" << endl;
if (this != &aa)
{
_a = aa._a;
}
return *this;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a;
};
//int main()
//{
// // 1、先用1構(gòu)造一個(gè)臨時(shí)對(duì)象 2、再用臨時(shí)對(duì)象拷貝構(gòu)造aa1
// // 3、同一個(gè)表達(dá)式中，連續(xù)構(gòu)造+構(gòu)造/構(gòu)造+拷貝構(gòu)造/拷貝構(gòu)造+拷貝構(gòu)造會(huì)合二為一
// // a、構(gòu)造+構(gòu)造->構(gòu)造
// // b、構(gòu)造+拷貝構(gòu)造->構(gòu)造
// // c、拷貝構(gòu)造+拷貝構(gòu)造->拷貝構(gòu)造
// A aa1 = 1;
// const A& aa2 = 2;
//
// return 0;
//}
//void func(A aa1)
//{
//
//}
//
//int main()
//{
// // 構(gòu)造
// A aa(1);
// // 拷貝構(gòu)造
// func(aa);
//
// //構(gòu)造+拷貝構(gòu)造->構(gòu)造
// func(A(2));
//
// //構(gòu)造+拷貝構(gòu)造->構(gòu)造
// func(3);
//
// return 0;
//}
A func()
{
A aa;
return aa;
}
int main()
{
// 拷貝構(gòu)造+拷貝構(gòu)造->拷貝構(gòu)造
//A aa1 = func();
A aa2;
aa2 = func();
return 0;
}
//int main()
//{
// A aa1(1); // 構(gòu)造
//
// // 一個(gè)已經(jīng)存在的對(duì)象拷貝初始化另一個(gè)要?jiǎng)?chuàng)建的對(duì)象，就是拷貝構(gòu)造
// // 他們兩是等價(jià)的
// A aa2(aa1); // 拷貝構(gòu)造
// A aa3 = aa1; // 拷貝構(gòu)造 or 賦值拷貝
//
// // 兩個(gè)已經(jīng)存在的對(duì)象拷貝，賦值拷貝
// aa2 = aa3;
//
//
// return 0;
//}
??7. 再次理解類(lèi)和對(duì)象
現(xiàn)實(shí)生活中的實(shí)體計(jì)算機(jī)并不認(rèn)識(shí)，計(jì)算機(jī)只認(rèn)識(shí)二進(jìn)制格式的數(shù)據(jù)。如果想要讓計(jì)算機(jī)認(rèn)識(shí)實(shí)生活中的實(shí)體，用戶必須通過(guò)某種面向?qū)ο蟮恼Z(yǔ)言，對(duì)實(shí)體進(jìn)行描述，然后通過(guò)編寫(xiě)程序，創(chuàng)建對(duì)象后計(jì)算機(jī)才可以認(rèn)識(shí)。比如想要讓計(jì)算機(jī)認(rèn)識(shí)洗衣機(jī)，就需要：
??1. 用戶先要對(duì)現(xiàn)實(shí)中洗衣機(jī)實(shí)體進(jìn)行抽象—即在人為思想層面對(duì)洗衣機(jī)進(jìn)行認(rèn)識(shí)，洗衣機(jī)有什么屬性，有那些功能，即對(duì)洗衣機(jī)進(jìn)行抽象認(rèn)知的一個(gè)過(guò)程
??2. 經(jīng)過(guò)1之后，在人的頭腦中已經(jīng)對(duì)洗衣機(jī)有了一個(gè)清醒的認(rèn)識(shí)，只不過(guò)此時(shí)計(jì)算機(jī)還不清楚，想要讓計(jì)算機(jī)識(shí)別人想象中的洗衣機(jī)，就需要人通過(guò)某種面相對(duì)象的語(yǔ)言(比如：C++、Java、Python等)將洗衣機(jī)用類(lèi)來(lái)進(jìn)行描述，并輸入到計(jì)算機(jī)中
??3. 經(jīng)過(guò)2之后，在計(jì)算機(jī)中就有了一個(gè)洗衣機(jī)類(lèi)，但是洗衣機(jī)類(lèi)只是站在計(jì)算機(jī)的角度對(duì)洗衣機(jī)對(duì)象進(jìn)行描述的，通過(guò)洗衣機(jī)類(lèi)，可以實(shí)例化出一個(gè)個(gè)具體的洗衣機(jī)對(duì)象，此時(shí)計(jì)算機(jī)才能洗衣機(jī)是什么東西
??4. 用戶就可以借助計(jì)算機(jī)中洗衣機(jī)對(duì)象，來(lái)模擬現(xiàn)實(shí)中的洗衣機(jī)實(shí)體了
在類(lèi)和對(duì)象階段，大家一定要體會(huì)到，類(lèi)是對(duì)某一類(lèi)實(shí)體(對(duì)象)來(lái)進(jìn)行描述的，描述該對(duì)象具有那些屬性，那些方法，描述完成后就形成了一種新的自定義類(lèi)型，才用該自定義類(lèi)型就可以實(shí)例化具體的對(duì)象
文章來(lái)源地址http://www.zghlxwxcb.cn/news/detail-810904.html
到了這里，關(guān)于【C++】：類(lèi)和對(duì)象（下）：explicit || 再談構(gòu)造函數(shù) || static成員 || 友元 || 內(nèi)部類(lèi) || 匿名對(duì)象 || 拷貝對(duì)象時(shí)的編譯器優(yōu)化問(wèn)題 || 再次理解類(lèi)和對(duì)象的文章就介紹完了。如果您還想了解更多內(nèi)容，請(qǐng)?jiān)谟疑辖撬阉鱐OY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！
