企业网站管理系统如何使用说明,两台wordpress共享mysql,石家庄站到石家庄北站,百度贴吧网页入口#x1f451;作者主页#xff1a;安 度 因 #x1f3e0;学习社区#xff1a;StackFrame #x1f4d6;专栏链接#xff1a;C修炼之路 文章目录 一、再谈构造函数1、初始化列表2、explicit 关键字 二、static 成员1、概念2、特性 三、友元1、友元函数2、友元类 四、内部类五… 作者主页安 度 因 学习社区StackFrame 专栏链接C修炼之路 文章目录 一、再谈构造函数1、初始化列表2、explicit 关键字 二、static 成员1、概念2、特性 三、友元1、友元函数2、友元类 四、内部类五、匿名对象六、构造(拷贝构造)对象时的一些编译器优化七、再谈类和对象 如果无聊的话就来逛逛 我的博客栈 吧! 一、再谈构造函数
1、初始化列表 初始化列表对于 构造函数构造与拷贝构造 来说以一个冒号开始接着一个以逗号分隔的数据成员列表每个成员变量后面跟一个放在括号中的初始值或表达式每个成员变量只能初始化一次对于变量来说可以初始化也可以不初始化 Date d1(2023, 2, 5); // 对象整体定义的地方
初始化列表对象的成员定义的地方例如 当然 _year 的括号内也可以为 -year 甚至是常量都可以。初始化时就会根据初始化列表的表达式内容进行初始化。
类中包含以下成员必须放在初始化列表位置进行初始化 const 成员变量引用成员变量没有默认构造函数的自定义类型成员变量(对象必须初始化如果没有默认构造的成员变量无法构造就要报错) 因为对于 const 修饰的变量来说必须在定义时初始化 否则后面不可改引用也是一个道理而对于没有默认构造函数的自定义类型由于无法自动调用它的默认构造函数所以也需要在定义时初始化。
对于
class A
{
private:int _year;int _month;int _day;const int _N;int _ref;A _aa;
};int main()
{A aa; // 对整个对象进行定义
}对于类中的成员它们只是成员变量的声明 不能在这里初始化而定义则是在主函数中对对象整体进行定义并不是成员定义的地方 当在构造函数中对 _N 进行初始化时报错了因为此刻 _N 已经被定义此刻是在函数体中无法再对其进行初始化 而使用初始化列表就可以因为初始化列表是成员变量定义的地方 无论是对于引用const 成员变量又或者是无构造函数的自定义类型成员自动调用非默认构造函数都可以完成初始化
class A
{
public:A(int a){ _a a; } // 非默认构造函数
private:int _a;
};class Date
{
public:Date(int year, int month, int day, int i):_N(10),_ref(i),_aa(-1){_year year;_month month;_day day;}private:int _year;int _month;int _day;const int _N;int _ref;A _aa;
};int main()
{Date d1(2023, 2, 6, 10);return 0;
}尽量使用初始化列表初始化因为不管你是否使用初始化列表对于自定义类型成员变量一定会先使用初始化列表初始化。
类 A
class A
{
public:A(int a 1) {cout 进行构造 endl;_a a; }A(const A a){cout 进行拷贝构造 endl;_a a._a;}A operator(const A a){cout 赋值重载 endl;_a a._a;return *this;}
private:int _a;
};看如下动图 虽然我们没有写初始化列表但是初始化列表是成员变量定义的地方所以 _aa 会在初始化列表定义的时候默认调用其构造函数。
所以适当时刻使用初始化列表可以效率提升因为此刻只发生一次拷贝构造存在成员初始化不存在成员 所以建议自定义类型的成员在初始化列表进行初始化更加高效 。
C11 中的补丁提供了给成员变量缺省值的方式若没有显示写缺省值的处理含缺省值的变量都会在初始化列表进行初始化 若显示写初识化列表了就使用初始化列表的。本质上还是使用初始化列表进行初始化因为初始化列表是成员定义的时候。
总结
哪个对象调用构造函数初始化列表是它所有成员变量定义的位置不管是否显示在初始化列表写那么编译器每个变量都会初始化列表定义初始化
反正记住一句话优先使用初始化列表初始化。
考察
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 1B.程序崩溃C.编译不通过D.输出1 随机值 因为成员变量在类中声明次序就是其在初始化列表中的初始化顺序与其在初始化列表中的先后次序无关 。
_a2 先声明所以初始化列表先初始化此刻 _a1 为随机值将随机值给 _a2 再初始化 _a1将 a 的值初始化为 1 。
所以建议将声明次序和初始化列表次序对应防止混淆。
2、explicit 关键字
隐式类型转换 Date d2 2022 时发生了隐式类型转换意义相似类型转换。由于支持单参数的构造函数所以这里用 2022 构造一个临时对象 Date tmp(2022)再用这个对象拷贝构造给 d2 但是 C 编译器在连续构造的过程中多个构造会被优化合二为一变为一个构造: d1 一次构造d2 一次构造一次拷贝构造合并为一次构造。 如果不想要实现隐式类型转换就可以加上 explicit 关键字修饰 这时就不会进行转换了。
对于单参数的构造函数可以支持应试类型转换。对于多参数的构造函数需要这么写
class A
{
public:A(int a):_a1(a){cout A(int) endl;}// explicit A(int a1, int a2) 如果不想要隐式转换则加 explicit 修饰A(int a1, int a2):_a1(a1), _a2(a2){}A(const A aa):_a1(aa._a1){cout A(const A aa) endl;}private:int _a2;int _a1;
};int main()
{A a3 { 2, 2 }; // 多参数隐式类型转换 return 0;
}对于 explicit 修饰的构造函数称为显示构造函数对于没有用 explicit 修饰的构造函数称为隐式构造函数。
二、static 成员
1、概念 声明为static的类成员称为类的静态成员用static修饰的成员变量称之为静态成员变量用static修饰的成员函数称之为静态成员函数。静态成员变量一定要在类外进行初始化 考题1
如何使用程序计算一个对象被构造了几次 但是对于全局变量可以随之改变
cnt;所以并不好如何让 cnt 和 A 绑定起来并且始终只有一个static 成员它属于整个类所有对象生命周期在整个程序运行期间 。static 成员在类的所有对象中都可以使用它并不在对象中而是在类中所有类对象只有一个staic 成员。
访问
若 static 成员为 public 静态成员变量可以用对象和类访问。
private
statoc 修饰的成员函数没有 this 指针所以在里面不能访问 _a
但是指定类域(.)和使用类作用限定符(::)就可以访问。 static 成员在类外面定义特例仅限于静态因为不能在某个构造函数定义它属于类不单独属于对象。
写一个 GetCnt 函数来获取 _sCnt 。静态成员函数可以用对象和类访问即 a1.GetCnt() A::Getcnt() 。
考题2 class Sum
{
public:Sum(){_ret _i;_i;}static int GetRet() // 静态成员函数{return _ret;}
private:static int _i; static int _ret;
};int Sum::_i 1;
int Sum::_ret 0;class Solution {
public:int Sum_Solution(int n) {Sum a[n]; // 构造 n 次// return Sum().GetRet() - (n 1); // 匿名对象多构造一次// return a[0].GetRet();return Sum::GetRet();}
};使用静态成员变量_i 初始化为 1, _ret 初始化为 0 两者在全局初始化。对 Sum 类的构造函数每次将 ret 累加并且让 _i 自增这样构造 n 次就可以计算出从 1 … n . 再写一个静态成员函数返回 _ret 这些为计算过程。
可以 Sum().GetRet() 使用匿名对象返回所以需要 Sum().GetRet() - (n 1)最好的返回方式还是用类来访问静态成员函数 Sum::GetRet() 还有很多种返回方式看注释。
在 C11 中提供了成员变量的缺省值 但是虽然将 _a 给为 0 但是说 int _a 0 是初始化并不对因为在 A 类中只是完成了对成员变量的声明。缺省值只是在未明确初始化时在该成员变量在初始化时才会默认使用这个缺省值。
如果在初始化列表阶段没有对成员变量初始化就会使用缺省值初始化 甚至在成员变量中给为 int* p (int*)malloc(4 * 10) 都是可以的但是记住这里是缺省值。
但是对于静态成员变量是不可以这样给缺省值的必须在类外面全局位置定义初始化 使一个对象只能在栈上创建/堆上创建
#include iostreamusing namespace std;class A
{
public:static A GetStackObj(){A aa;return aa;}static A* GetHeapObj(){return new A;}// 封装成私有只能在类内部调用// 这样子就不能直接创建对象
private:A(){}private:int _a1 1;int _a2 2;
};int main()
{// 但是调用两个成员函数就会被对象和成员函数的优先级所困扰// 因为调用需要有一个对象但是对象的指定创建范围不同// 这时就可以使用静态成员函数// static A GetStackObj();return 0;
}2、特性 静态成员为所有类对象所共享不属于某个具体的对象存放在静态区静态成员变量必须在类外定义定义时不添加static关键字类中只是声明类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问静态成员函数没有隐藏的this指针不能访问任何非静态成员静态成员也是类的成员受public、protected、private 访问限定符的限制静态变量成员不可以给缺省值得在全局定义非静态能调用静态静态不能调用非静态因为调用非静态要传递 this 指针但是 static 成员没有 this 指针 三、友元 友元提供了一种突破封装的方式有时提供了便利。但是友元会增加耦合度破坏了封装所以友元不宜多用。 友元分为友元函数和友元类 友元就像黄牛一样破坏管理规则能不用就不用。
1、友元函数
我们有没有思考过一个问题既然运算符可以重载那么流插入与流提取操作符 和 是否可以重载呢
能否将对象像内置类型一样输入和打印就像这样 可以C 允许重载这两个操作符就拿 来说
对于流插入操作符来说有两个参数 cout 和 d1 cout 的类型为 ostream ostream 本身是一个类对象并且 能自动匹配类型的原因是因为运算符重载过了而对于自定义类型并没有重载。可以理解为 已经进行过了函数重载 运算符重载。
我们试着在类中写一下
void Date::operator(ostream out)
{out _year - _month - _day endl;
}形参 out 为 cout 的别名通过这种方式在主函数中调用 发现是无法调用的但是如果我们主动调用 : 这是因为在运算符重载中对于双操作数的操作符重载第一个参数是操作数第二个参数是右操作数。 而我们上方的写法让 cout 变为了第二个操作数就相当于变成了 d1 cout 错乱了 但是这很明显不符合我们的习惯。而 this 指针已经占用了第一个参数左操作数一定是对象所以如果写重载的话一定实现不就不能写作成员函数。
所以就写在类外面写作全局的不就好了这样就不受类的特性的约束了 但是这里又迎来一个问题访问不到类中的成员变量 对于这个问题我们也遇到过要么是将类成员变量私有权限放开要么是给一个调取数据的函数但是这样虽然可以解决调取数据的问题可是对于 流提取函数的实现又成了一个问题无法获取到输入数据而使用这种方案解决了也很麻烦所以这两种方案都被排除了。
那么有没有什么简便的方法一个全局函数想用对象访问类中私有或保护的成员可以使用友元。意思就是让类的“朋友”访问到它的私有对象。
友元函数的声明需要写在类里面 此刻就可以访问了 但是这里不能连续输出 和之前讲过的连续赋值的原因是相同的因为 cout d1 d2; 由于函数没有返回值并不能起到连续输出的效果。所以可以稍加改进让每次输出后都可以获取 cout 这时就可以连续输出了 同理对于 的函数我们也可以写出来
istream operator(istream in, Date d) // d 要被修改不能加 const
{in d._year d._month d._day;return in;
}总结 友元函数可访问类的私有和保护成员但不是类的成员函数友元函数 不能用const修饰友元函数可以在 类定义的任何地方声明不受类访问限定符限制一个函数可以是多个类的友元函数友元函数的调用与普通函数的调用原理相同 2、友元类
友元类的所有成员函数都变为是另一个类的友元函数都可以访问另一个类中的非公有成员 。
友元关系是单向的不具有交换性
class Time
{// 日期类想要经常访问 Time 让 Date 变为 Time 的友元类friend class Date; // 声明日期类为时间类的友元类则在日期类中就直接访问Time类中的私有成员变量
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){// 直接访问时间类私有的成员变量_t._hour hour;_t._minute minute;_t._second second;}
private:int _year;int _month;int _day;Time _t;
};比如上述Time类和Date类在Time类中声明Date类为其友元类Date 类为 Time 类的友元。那么可以在Date类中直接访问Time类的私有成员变量 但想在Time类中访问Date类中私有的成员变量则不行。
但是 Time 类不能访问 Date 类 。举个中二的例子就好比说Date 类是主Time 类是仆Date 类和 Time 类缔结了神魂契约对于 Date 类来说可以随时查看 Time 的情况但是对于 Time 并不能随时查看 Date 的情况除非它俩关系对等签订平等的契约才可以在 Date 类中声明 Time 类为其友元类
class Time
{// 日期类想要经常访问 Time 让 Date 变为 Time 的友元类friend class Date; // 声明日期类为时间类的友元类则在日期类中就直接访问Time类中的私有成员变量
public:Time(int hour 0, int minute 0, int second 0): _hour(hour), _minute(minute), _second(second){}void Func(Date d);
private:int _hour;int _minute;int _second;
};
class Date
{friend class Time;
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){// 直接访问时间类私有的成员变量_t._hour hour;_t._minute minute;_t._second second;}private:int _year;int _month;int _day;Time _t;
};void Time::Func(Date d) // Date 和 Time 两者互为友元所以 Time 中现在可以访问 Date
{cout d._year endl;
}int main()
{return 0;
}友元类和友元函数一样不受访问限定符的约束 如图在 A 类中将友元类 C 的声明放为私有其实平时放在 class 中也就是私有这里只是为了说明此刻 C 能访问 A 在主函数创建对象时A 也通过构造完成初始化调用 c1 的成员函数也访问到了 A 的成员。 友元关系不能传递 如果C是B的友元 B是A的友元则不能说明C时A的友元。 友元关系不能继承在继承位置再详细介绍。 四、内部类 概念如果一个类定义在另一个类的内部这个类就叫做内部类。内部类是一个独立的类它不属于外部类更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。 注意内部类就是外部类的友元类参见友元类的定义内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。 对外部类大小的计算和内部类中的成员变量没有关系因为里面并没有包含对象只是图纸而已 再看一个例子
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}private:int _b;};void f(B b){// cout b._b endl; // err 外部类不能访问内部类的私有}
};
int A::k 1;
int main()
{A::B b; // 内部类的定义return 0;
}内部类 B 和在全局定义时基本一样的但是外部类 A 类域限制定义在 A 的类域中就比如定义内部类对象时需要指定外部类的类域A::B b
内部类 B 天生就是外部类 A 的友元也就是 B 中可以访问 A 的私有A 不能访问 B 的私有 就比如 B 类中可以访问 A 中私有成员变量但是 A 不能访问 B 的私有除非将权限开放为公有。
内部类改写 JZ76
class Solution {
private:class Sum{public:Sum(){_ret _i;_i;}};
private:static int _i;static int _ret;
public:int Sum_Solution(int n) {Sum a[n];return _ret;}
};int Solution::_i 1;
int Solution::_ret 0;将 Sum 包为内部类并将 _i 和 _ret 变为 Solution 的成员变量Sum 默认为 Solution 的友元那么 Sum 可以访问这两个成员。而返回时也不需要借助成员函数直接返回成员变量即可。
优点根据内部类的特性将成员变量放到 Solution 后根据两者的特性就可以访问到 _ret 这时不再需要使用成员函数获取 _ret
五、匿名对象
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 aa1();// 不能这么定义对象因为编译器无法识别下面是一个函数声明还是对象定义// 但是我们可以这么定义匿名对象匿名对象的特点不用取名字// 但是他的生命周期只有这一行我们可以看到下一行他就会自动调用析构函数A();A aa2(2);// 匿名对象在这样场景下就很好用当然还有一些其他使用场景这个我们以后遇到了再说Solution().Sum_Solution(10);return 0;
}六、构造(拷贝构造)对象时的一些编译器优化
在同一句语句中不存在的对象或者有多个构造或拷贝构造这些构造过程可能会合二三为一。
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;
};
void f1(A aa)
{}
A f2()
{A aa;return aa;
}
int main()
{// 传值传参A aa1;f1(aa1);cout endl;// 传值返回f2();cout endl;// 隐式类型连续构造拷贝构造-优化为直接构造f1(1);// 一个表达式中连续构造拷贝构造-优化为一个构造f1(A(2));cout endl;// 一个表达式中连续拷贝构造拷贝构造-优化一个拷贝构造A aa2 f2();cout endl;// 一个表达式中连续拷贝构造赋值重载-无法优化aa1 f2();cout endl;return 0;
}七、再谈类和对象
现实生活中的实体计算机并不认识计算机只认识二进制格式的数据。如果想要让计算机认识现实生活中的实体用户必须通过某种面向对象的语言对实体进行描述然后通过编写程序创建对象后计算机才可以认识。比如想要让计算机认识洗衣机就需要 用户先要对现实中洗衣机实体进行抽象—即在人为思想层面对洗衣机进行认识洗衣机有什么属性有那些功能即对洗衣机进行抽象认知的一个过程 经过1之后在人的头脑中已经对洗衣机有了一个清醒的认识只不过此时计算机还不清楚想要让计算机识别人想象中的洗衣机就需要人通过某种面相对象的语言(比如C、Java、Python等)将洗衣机用类来进行描述并输入到计算机中 经过2之后在计算机中就有了一个洗衣机类但是洗衣机类只是站在计算机的角度对洗衣机对象进行描述的通过洗衣机类可以实例化出一个个具体的洗衣机对象此时计算机才能洗衣机是什么东西。 用户就可以借助计算机中洗衣机对象来模拟现实中的洗衣机实体了。 在类和对象阶段大家一定要体会到类是对某一类实体(对象)来进行描述的描述该对象具有那些属性那些方法描述完成后就形成了一种新的自定义类型才用该自定义类型就可以实例化具体的对象 。
