类和对象:完结
1.再深构造函数
#include<iostream>
using namespace std;
class A
{
public:
//如果不想让类型转换发生,可以在构造函数前加explicit函数
/*explicit A(int a = 0)
{
_a1 = a;
}*///多参数也是如此
A(int a = 0)//单参数可以
{
_a1 = a;
}
A(int a1, int a2)
{
_a1 = a1;
_a2 = a2;
}
A(const A& aa)
{
_a1 = aa._a1;
}
void Print()
{
cout << _a1 << " " << _a2 << endl;
}
private:
int _a1 = 1;
int _a2 = 2;
};
class Stack
{
public:
void Push(const A& aa)//临时对象具有常性,要加const
{
//...
}
private:
A _arr[10];
int _top;
};
int main()
{
A aa1(1);//调用构造
aa1.Print();
// 隐式类型转换,类型转换会生成中间变量
// 2先构造⼀个A的临时对象,再⽤这个临时对象拷⻉构造aa2
// 编译器遇到连续构造+拷⻉构造->优化为直接构造
//调试观察
A aa2 = 2;
aa2.Print();
A& raa1 = aa2;
//A& aa2 = 2;可以验证:
//并不是直接构造,会生成临时变量,具有常性
const A& aa2 = 2;
//真正用意:
Stack st;
A aa3(3);
st.Push(aa3);
//写起来更简单,消耗是一样的
st.Push(3);
//多参数:
//A aa4 = 1, 1;//不支持
//但是:C++11后才支持多参数转换
A aa4 = { 1, 1 };
const A& raa5 = { 2,2 };
st.Push(aa4);
st.Push({ 2,2 });
return 0;
}
注意:初始化列表是他定义的地方,那么每个成员都会去走初始化列表,哪怕是不写
还有一类:自定义类型:
EG:
class Time
{
public:
Time(int hour = 1)
:_hour(hour)
{
cout << "Time()" << endl;
}
private:
int _hour;
};
不在初始化列表中定义, 不写也走:只调用Time的默认构造函数(无参/全缺省)
如果Time没有默认构造,调不到,只能自己传,爱传什么传什么:
无默认构造:
class Time
{
public:
Time(int hour)
:_hour(hour)
{
cout << "Time()" << endl;
}
private:
int _hour;
};
class Date
{
public:
Date(int& xx, int year, int month, int day)
: _year(year)
, _month(month)
, _day(day)
, _n(1)
, _ref(xx)
, _t(1)
{}
void Print()const
{
cout << _year << "年" << _month << "月" << _day << "日" << endl;
}
private:
//声明
int _year;
int _month;
int _day;
const int _n;
int& _ref;
Time _t;
};
初始化列表和函数体内可以混着赋值:
EG:(初始化列表和函数体可以打配合)
Date()
:_ptr((int*)malloc(12))
{
//初始化列表和函数体内可以混着赋值
if (_ptr == nullptr)
{
perror("malloc fail");
}
else
{
memset(_ptr, 0, 12);
}
}
private:
//声明,后面为缺省值->初始化列表用的
int _year = 1;
int _month = 1;
int _day = 1;;
可以无参调用的才是默认构造:(以下并不是)
#include<iostream>
using namespace std;
class Date
{
public:
Date(int year, int month, int day)
: _year(year)
, _month(month)
//, _day(day)对于内置类型,是不做处理的,可能是个随机值
{
}
void Print()const
{
cout << _year << "年" << _month << "月" << _day << "日" << endl;
}
private:
//声明,后面为缺省值->初始化列表用的
int _year = 1;
int _month = 1;
int _day = 1;;
};
int main()
{
Date d1(2024, 7, 14);
d1.Print();
Date d2;//会报错,所以并不是默认构造
return 0;
}
private:
int _year = 1;
int _month = 1;
int _day = 1;;
int* _ptr = (int*)malloc(12);
Time _t = 1;
#include<iostream>
using namespace std;
class A
{
public:
A(int a)
:_a1(a)
, _a2(_a1)
{}
void Print() {
cout << _a1 << " " << _a2 << endl;
}
private:
int _a2 = 2;
int _a1 = 2;
};
int main()
{
A aa(1);
aa.Print();
}
2.类型转换
• C++⽀持内置类型隐式类型转换为类类型对象,需要有相关内置类型为参数的构造函数• 构造函数前⾯加explicit就不再⽀持隐式类型转换
3.static成员
#include<iostream>
using namespace std;
class A
{
public:
A()
{
++_scount;
}
A(const A& t)
{
++_scount;
}
~A()
{
--_scount;
}
private:
// 类⾥⾯声明
static int _scount;
};
// 类外⾯初始化
int A::_scount = 0;
int main()
{
return 0;
}
static int GetACount()
{
return _scount;
}
static int GetACount()
{
_a++;//报错//不能访问⾮静态的,因为没有this指针
return _scount;
}
void func()
{
cout << _scount << endl;
cout << GetACount() << endl;
}
cout << A::GetACount() << endl;
cout << a1.GetACount() << endl;
4.友元
#include<iostream>
using namespace std;
// 前置声明,不然则A的友元函数声明编译器不认识B//-----注意点
class B;//-----解决点
class A
{
// 友元声明
friend void func(const A& aa, const B& bb);//-----问题点
private:
int _a1 = 1;
int _a2 = 2;
};
class B
{
// 友元声明
friend void func(const A& aa, const B& bb);
private:
int _b1 = 3;
int _b2 = 4;
};
void func(const A& aa, const B& bb)
{
cout << aa._a1 << endl;//~~~~~~~~~~~~~~~~~~~~~~~~~
cout << bb._b1 << endl;//一个函数成为多个类的友元
}
int main()
{
A aa;
B bb;
func(aa, bb);
return 0;
}
• 友元类中的成员函数都可以是另⼀个类的友元函数,都可以访问另⼀个类中的私有和保护成员;
#include<iostream>
using namespace std;
class A
{
// 友元声明
friend class B;//把B定义成A的友元类-----解决点---B的成员函数都成为了A的友元函数
private:
int _a1 = 1;
int _a2 = 2;
};
class B
{
public://B要一直访问A类的私有保护成员-----问题点
void func1(const A& aa)
{
cout << aa._a1 << endl;
cout << _b1 << endl;
}
void func2(const A& aa)
{
cout << aa._a2 << endl;
cout << _b2 << endl;
}
private:
int _b1 = 3;
int _b2 = 4;
};
int main()
{
A aa;
B bb;
bb.func1(aa);
bb.func1(aa);
return 0;
}
• 友元类的关系是单向的,不具有交换性,⽐如A类是B类的友元,但是B类不是A类的友元;
5.内部类
#include<iostream>
using namespace std;
class A
{
private:
static int _k;
int _h = 1;
public:
class B // B默认就是A的友元
{
public:
void foo(const A& a)
{
cout << _k << endl; //OK
cout << a._h << endl; //OK
}
private:
int _b = 1;
};
};
int A::_k = 1;
int main()
{
cout << sizeof(A) << endl;//4:实际上只有一个_h,没带_b//B不是A的成员
A::B b;//指定B是属于A的类域(受访问限定符限制)
A aa;
b.foo(aa);
return 0;
}
6.匿名对象
#include<iostream>
using namespace std;
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;
A aa2(2);
// 不能这么定义对象,因为编译器⽆法识别下⾯是⼀个函数声明,还是对象定义
//A aa1();
// 但是我们可以这么定义匿名对象,匿名对象的特点不⽤取名字,
// 但是他的⽣命周期只有这⼀⾏,我们可以看到下⼀⾏他就会⾃动调⽤析构函数
A();
A(1);
// 匿名对象在这样场景下就很好⽤,当然还有⼀些其他使⽤场景,这个我们以后遇到了再说
cout << Solution().Sum_Solution(10) << endl;//就是为了更方便
//有名
Solution st;
cout << st.Sum_Solution(10) << endl;
return 0;
}
7.对象拷贝时的编译器优化
#include<iostream>
using namespace std;
class A
{
public:
A(int a = 0)
:_a1(a)
{
cout << "A(int a)" << endl;
}
A(const A& aa)
:_a1(aa._a1)
{
cout << "A(const A& aa)" << endl;
}
A& operator=(const A& aa)
{
cout << "A& operator=(const A& aa)" << endl;
if (this != &aa)
{
_a1 = aa._a1;
}
return *this;
}
~A()
{
cout << "~A()" << endl;
}
void Print()
{
cout << "A::Print " << _a1 << endl;
}
private:
int _a1 = 1;
};
单参数类型的构造函数的隐式类型转化的优化示例:
int main()
{
//单参数类型的构造函数的隐式类型转化
A aa1 = 1;//构造加拷贝构造(构造临时对象,对临时对象进行拷贝构造)(因为类型转化会产生临时对象)
//开始执行发现:编译器优化成直接拷贝
const A& aa2 = 1;//生成临时对象,是引用,没有拷贝构造
return 0;
}
传参优化示例:
void f1(A aa)//传值传参---会产生一个拷贝
{}
void f2(A& aa)
{}
int main()
{
A aa1(1);//构造
//f1(aa1);//实参传给形参进行拷贝:调用构造,拷贝构造//不会优化:一般是在连续一个步骤才有优化//但是不排除其他更激进的
cout << endl;
//用引用:减少拷贝构造
f2(aa1);
cout << endl;
//用匿名对象:在连续过程
f1(A(1));//优化成直接构造
cout << endl;
f1(1);//本意是1走隐式类型转化,生成临时对象,再拷贝构造:优化成直接构造
cout << endl;
return 0;
}
传返回值优化示例:
A f3()//传值传参返回:会产生一个临时对象:因为aa出了作用域就销毁了
{
A aa(1);
return aa;//产生临时对象
}
//应该是aa作为局部对象,出了作用域销毁,调用~A(),由aa产生临时对象调用Print
//VS2022优化:严格来说没有生成aa,合二为一,只生成临时对象:看执行结果可推
int main()
{
f3().Print();//因为临死对象:构造+拷贝构造//用产生的临时对象调用Print//临时对象的周期就在这一行
cout << endl;
return 0;
}
A f4()
{
A aa(1);//构造
return aa;//拷贝构造
}
//优化:省略了临时对象,VS2022更激进,连aa都省掉了建议用2019-debug观察
int main()
{
A ret = f4();//拷贝构造
ret.Print();
cout << endl;
return 0;
}
A f4()
{
A aa(1);//构造
cout << "~~~~~~~~~" << endl;//构造了aa,aa充当临时对象
return aa;//拷贝构造
}
int main()
{
A ret;
ret = f4();//赋值//赋值完后。临时对象析构
ret.Print();
cout << endl;
return 0;
}
原文地址:https://blog.csdn.net/Small_entreprene/article/details/140555340
免责声明:本站文章内容转载自网络资源,如本站内容侵犯了原著者的合法权益,可联系本站删除。更多内容请关注自学内容网(zxcms.com)!