网站建设的费用报价,wordpress主题函数,招聘网站开发的要求,青岛谁做网站多少钱这里是目录 构造函数#xff08;续#xff09;构造函数体赋值初始化列表 explicit关键字隐式类型转换 static成员友元友元函数友元类 内部类匿名对象匿名对象的作用const引用匿名对象 构造函数#xff08;续#xff09;
构造函数体赋值
在创建对象时#xff0c;编译器通… 这里是目录 构造函数续构造函数体赋值初始化列表 explicit关键字隐式类型转换 static成员友元友元函数友元类 内部类匿名对象匿名对象的作用const引用匿名对象 构造函数续
构造函数体赋值
在创建对象时编译器通过调用构造函数给对象中各个成员变量一个合适的初始值
class Date
{
public:Date(int year, int month, int day){_year year;_month month;_day day;}private:int _year;int _month;int _day;
};初始化列表
初始化列表以一个冒号开始接着是一个以逗号分隔的数据成员列表每个成员变量后面跟一个放在括号中的初始值或表达式
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; // 没有默认构造函数//特征必须在定义的时候初始化int _ref; // 引用const int _n; // const
};int main()
{int x 20;B b1(10,x);return 0;
}注意 每个成员变量在初始化列表中最多只能出现一次(初始化只能初始化一次) 类中包含以下成员必须放在初始化列表位置进行初始化 引用成员变量const成员变量自定义类型成员(且该类没有默认构造函数时 尽量使用初始化列表初始化因为不管你是否使用初始化列表对于自定义类型成员变量一定会先使用初始化列表初始化 成员变量在类中声明次序就是其在初始化列表中的初始化顺序与其在初始化列表中的先后次序无关
class A
{
public:A(int a):_a1(a),_a2(_a1){}void Print() {cout _a1 _a2 endl;}
private:int _a2;int _a1;
};int main()
{A a(1);a.Print();return 0;
}运行结果 这里的声明顺序是a2 - a1所以在初始化的时候就是先初始化a2随机值再初始化a1 建议声明的顺序和定义的顺序保持一致可以减少错误的发生 explicit关键字
隐式类型转换
class A
{
public:A(int a):_a(a){}private:int _a;
};
int main()
{A a1(1);A a2 2;//隐式类型转换一个整型转换成自定义类型//2构造一个A的临时对象临时对象再拷贝构造a2 --优化为用2直接构造//临时对象具有常性需要加constconst A a3 3;//这里也会发生隐式类型转换return 0;
}那如果我们不希望发生转换该怎么处理 那么就可以加上 explicit
class A
{
public:explicit A(int a):_a(a){}private:int _a;
};
int main()
{A a1(1);A a2 2;//隐式类型转换一个整型转换成自定义类型//2构造一个A的临时对象临时对象再拷贝构造a2 --优化为用2直接构造//临时对象具有常性需要加constconst A a3 3;//这里也会发生隐式类型转换return 0;
}加上了 explicit就无法发生隐式转换因此这段代码就会报错 static成员
声明为static的类成员称为类的静态成员用static修饰的成员变量称之为静态成员变量用static修饰的成员函数称之为静态成员函数。静态成员变量一定要在类外进行初始化
class A
{
public:A(){ }A(const A t) { }~A() { }private:};我们想知道当前还有多少个A对象正在使用该怎么办 我们可以使用全局变量进行统计构造一次加一析构一次减一
int _count 0;class A
{
public:A(){ _count;}A(const A t) { _count;}~A() { --_count;}private:};int main()
{//全局变量的劣势 - 任何地方都可以随意改变_count;return 0;
}但是全局变量有一个劣势就是任何地方都可以对他进行修改这样的数据就会非常不安全 那么我们就可以把我们的数据封装在类里面
class A
{
public:A()//不能这样定义因为他不是属于某个对象的成员他是属于全局的//:_count(0);{ _count;}A(const A t) { _count;}~A() { --_count;}//因为是私有的数据所以需要一个共有的成员函数来访问//静态成员函数 - 特点没有this指针指定类域和访问限定符就可以访问//静态成员变量和静态成员函数一般是配套出现的static int GetCount(){return _count;}
private://成员变量 - 存储在对象里面int _a 1;int _b 2;//静态成员变量 - 存储在静态区//同理这里也是声明也是需要在类外面定义static int _count;//区别成员变量 - 属于每一个类对象//静态成员变量 - 属于类属于类的每个对象共享
};//全局位置类外面定义(可以突破一次私有
int A::_count 0;void Func()
{static A a2;cout __LINE__ - A::GetCount() endl;
}
int main()
{A a1;cout __LINE__ - A::GetCount() endl;Func();Func();return 0;
} __LINE__显示当前行数 运行效果 静态成员为所有类对象所共享不属于某个具体的对象存放在静态区静态成员变量必须在类外定义定义时不添加static关键字类中只是声明类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问静态成员函数没有隐藏的this指针不能访问任何非静态成员静态成员也是类的成员受public、protected、private 访问限定符的限制 友元
友元提供了一种突破封装的方式有时提供了便利但是友元会增加耦合度破坏了封装所以友元不宜多用
友元函数
class Date
{//友元函数声明//友元函数可以直接访问类的私有成员它是定义在类外部的普通函数不属于任何类//但需要在类的内部声明声明时需要加friend关键字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;
}运行效果 友元函数可访问类的私有和保护成员但不是类的成员函数 友元函数不能用const修饰 友元函数可以在类定义的任何地方声明不受类访问限定符限制 一个函数可以是多个类的友元函数 友元函数的调用与普通函数的调用原理相同 友元类
class Time
{//声明Date类为Time的友元类在Date类中就直接访问Time类中的私有成员变量friend class Date;
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;}void Print(){cout _t._hour - _t._minute - _t._second endl;}private:int _year;int _month;int _day;Time _t;
};int main()
{//可以在Date类中直接访问Time类的私有成员变量//但在Time类中访问Date类中私有的成员变量则不行Date d1;//通过Date类设置Time类的私有成员d1.SetTimeOfDate(22, 30, 10);//通过Date类访问Time类的私有成员d1.Print();return 0;
}
运行效果 友元关系不能传递 如果B是A的友元C是B的友元则不能说明C时A的友元 友元类的所有成员函数都可以是另一个类的友元函数都可以访问另一个类中的非公有成员 内部类
如果一个类定义在另一个类的内部这个内部类就叫做内部类 内部类可以是公有、私有、保护
class A
{
private:static int k;int h;
public:class B //内部类是外部类的友元{public:private:int b;};
};int A::k 1;int main()
{cout sizeof(A) endl;return 0;
}运行结果 从结果可以看到B类虽然定义在了A类里面但是B类并不占用空间 内部类是外部类的友元所以我们可以通过B类访问A类的成员
class A
{
private:static int _k;int _h 20;
public:class B //内部类是外部类的友元 - B可以访问AA不能访问B{public:void Print(const A a){cout a._k endl;//OK//内部类可以直接访问外部类中的static成员不需要外部类的对象/类名cout _k endl;//OKcout a._h endl;//OKcout _b endl;}private:int _b 30;};
};int A::_k 10;int main()
{A a1;//内部类实例化//如果内部类为私有则无法实例化A::B b1;b1.Print(a1);return 0;
}运行效果
匿名对象
class A
{
public:A(int a 0):_a(a){cout 调用构造函数 endl;}~A(){cout 调用析构函数 endl;}private:int _a;
};int main()
{A a1(1);//有名对象A(2);//匿名对象没有名字return 0;
}运行效果
匿名对象的作用
class A
{
public:A(int a 0):_a(a){cout 调用构造函数 endl;}~A(){cout 调用析构函数 endl;}private:int _a;
};class Solution
{
public:int Sum_Solution(int n){cout 已调用Sum_Solution endl;return n;}
};int main()
{A a1(1);//有名对象A(2);//匿名对象没有名字)//如果我们想调用Sum_Solution//可以这样调用Solution s;s.Sum_Solution(10);//还可以使用匿名对象调用//如果只想调用一次则可以使用这种方法//类型不能调用函数需要加()//如果没有默认构造则需要传参有几个参数就传几个 - Solution(1).Sum_Solution(20);Solution().Sum_Solution(20);return 0;
}运行效果 从运行结果还可以看出匿名对象的生命周期只在当前行而有名对象的生命周期在当前函数局部域 匿名对象和临时对象一样具有常性 const引用匿名对象
虽然匿名对象的生命周期只在当前行但是const引用会延长匿名对象的生命周期生命周期在当前函数局部域
class A
{
public:A(int a 0):_a(a){cout 调用构造函数 endl;}~A(){cout 调用析构函数 endl;}private:int _a;
};class Solution
{
public:int Sum_Solution(int n){cout 已调用Sum_Solution endl;return n;}
};int main()
{A a1(1);//有名对象A(2);//匿名对象没有名字)//A ra A(3); //匿名对象具有常性const A ra A(4);Solution().Sum_Solution(20);return 0;
}运行效果 补充编译器的优化
class A
{
public:A(int a 0):_a(a){cout 调用构造函数 endl;}~A(){cout 调用析构函数 endl;}private:int _a;
};A Func()
{A aa;return aa;
}int main()
{//编译器会对连续的构造进行优化A a1 Func(); //拷贝构造拷贝构造 -优化为拷贝构造cout ------------- endl;//这种写法干扰了编译器的优化A a2;a2 Func();//这种写法编译器不会进行优化应该避免这种写法return 0;
}运行效果 以上就是本篇文章的全部内容了希望大家看完能有所收获
