制作网站的步骤是什么,开不锈钢公司怎么做网站,报社网站建设方案,基于html的个人网站的设计与实现论文作者:chlorine 专栏:c专栏 目录
#x1f6a9;再谈构造函数
#x1f393;构造函数体赋值
#x1f393;初始化列表
#x1f6a9;explicit关键字
#x1f6a9;static成员
#x1f393;概念
面试题#xff1a;计算创建多少个类对象
#x1f393;特性
【问题】(非)… 作者:chlorine 专栏:c专栏 目录
再谈构造函数
构造函数体赋值
初始化列表
explicit关键字
static成员
概念
面试题计算创建多少个类对象
特性
【问题】(非)静态调用(非)静态
【题目】累加
友元
友元函数
友元类
内部类
特性
特性一内部类定义在public中
特性一内部类定义在private中
特性三类大小
匿名对象
特性一生命周期
特性二匿名对象具有常性
拷贝对象时一些编译器优化 再谈构造函数
我们之前学了构造函数对成员函数体内成员变量赋初值——构造函数体赋值。
这一章我们要学习 对成员变量初始化——初始化列表
构造函数体赋值 构造函数体赋值在创建对象时编译器通过调用构造函数给对象中各个成员变量一个合适的初始值。 虽然上述构造函数调用之后对象中已经有了一个初始值但是不能将其称为对对象中成员变量的初始化 构造函数体中的语句只能将其称为赋初值而不能称作初始化。因为初始化只能初始化一次而构造函数体内可以多次赋值。 初始化列表 初始化列表以一个 冒号:开始 接着是一个以 逗号,分隔的数据成员列表 每个 成员变量 后面跟一个 放在括 号中的初始值或表达式。 class Date
{
public:Date(int year, int month, int day):_year(year),_month(month),_day(day){}
private:int _year;int _month;int _day;
}; 为什么要有初始化列表呢——是因为有些成员必须在初始化列表初始化。所以衍生出了初始化列表。 【注意】 1. 每个成员变量在初始化列表中最多只能出现一次(初始化只能初始化一次). 2. 类中包含以下成员必须放在初始化列表位置进行初始化(必须在定义的时候初始化 引用成员变量 const成员变量 成员变量实际上是在声明在main函数中创建对象B bb(10,1)其实就是定义的过程但是这个定义对所有的成员变量都定义了没有给单个成员变量定义 那在哪对成员进行定义呢 那么我们就衍生了初始化列表对象的成员定义的位置。记住有且仅一次初始化 class B
{
public://初始化列表对象成员定义的地方B(int a, int ref) :_n(1),_ref(ref){}
private://声明const int _n; // const int _ref; // 引用
};
int main()
{//对象整体定义B bb(10, 1);return 0;
} 自定义类型成员(且该类没有默认构造函数时) 我们之前就学过了自定义类型成员会自动调用默认构造函数内置类型不会进行处理会给个随机值 我们也可以给内置成员变量打个补丁int x1;这里的1是缺省值缺省值是给初始化列表的 如果我们给x初始化那么编译器就不会用缺省值缺省值在大部分学c的人叫成备胎初始化了那么就不需要缺省值没有初始化就需要缺省值。 如果自定义类型的成员没有默认构造函数那么自定义类型的成员就会报错没有合适的构造函数可用这就需要给自定义类型的成员初始化了。 在没有默认构造函数给初始值我们就需要在初始化列表进行定义 如果有默认构造我们能不能再初始化列表中定义呢——当然可以 只不过初始化列表优先处理。其实本质上默认构造里的参数也是缺省参数如果我们给了缺省参数 但是初始化列表初始化了就不需要缺省值来初始化了。所以默认构造函数(隐式或者初始化列表(显式)都是一种初始化但是在后来的初始化都是利用初始化列表进行初始化。 3. 尽量使用初始化列表初始化因为不管你是否使用初始化列表对于自定义类型成员变量一定会先使用初始化列表初始化。 自定义类型是一定要调用构造函数的有默认构造函数没有初始化列表就会调用默认构造函数没有默认构造函数就必须要使用初始化列表初始化。 所以这里的自定义类型成员变量前提是没有默认构造函数则一定要用初始化列表初始化。 注意初始化列表是构造函数的一部分初始化列表严格说替代了构造函数体内赋值以后我们就可以开始用初始化列表来初始化了。 但是我们要知道初始化列表并不能完成初始化所有的内容比如我们要开辟一个空间malloc可以这样写 :a((int*)malloc(capacity*sizeof(int) 但是我们是不是得检查一下是否开辟空间成功 Stack(int capacity10)
:_a((int*)malloc(capacity*sizeof(int)))
,_top(0)
,_capacity(capacity)
{if(_anullpter){perror(malloc fail\n);return -1;}
} 所以我们需要在函数内进行检查初始化列表能帮我们完成95%的内容但是还剩5%是初始化列表无法完成上面的例子就是。 还有给数组初始化一下我们就需要memsetcalloc也需要检查.....等等 还有更多复杂的过程就无法让初始化列表来完成的。 函数体分工就是初始化列表不方便做的。 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.编译不通过
D.输出1 随机值 4. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序与其在初始化列表中的先后次序无关 为什么选D呢按照上面的特点声明的次序就是初始化列表中的初始化顺序成员变量就是声明的过程所以先声明_a2那么就先初始化_a2为_a1,那么_a1就是1_a2就是随机值了。 就比如在上面对_a开辟空间之后里面的_capacity就是一个随机值随后的声明的是_capacity就会变得很大导致了程序的崩溃所以我们必须以后声明顺序和初始化顺序相同。 explicit关键字 class A
{
public:A(int a):_a(a){cout A(int a) endl;}A(const A aa):_a(aa._a){cout A(const A aa) endl;}
private:int _a;
};
int main()
{A aa1(1);//拷贝构造A aa2 2;return 0;
} 我们看看上面一段代码A aa22,运行成功并且还调了构造函数。 看下面一段代码隐式类型转换我们根据前面所学的知识我们知道有隐式类型转换的过程中会自动生成一个临时变量b是int类型b的值给与d类型相同的临时变量然后进行赋值。所以这里的编译成功。 int b10;
double db; 那么这里的int型隐式类型转换成自定义类型是不是也是会在其中默认生成一个临时变量。——是的。其过程就是2创造一个A的临时对象临时对象再拷贝构造aa2再近代我们的编译对其进行优化2直接构造了。所以我们的运行成功调用了拷贝构造函数。 所以下面的表达式经历了——创建临时变量——拷贝构造——优化 ——三大过程。 A aa22;那我们接下来看看下面的代码 这里Aaa32就无法进行构造了。因为2在赋值的时候不是直接赋值而是我们在中间创建的临时变量是具有常性的是const类型是不可以改变的而中间创建的临时变量的对象是A类而且是const的A类然后我们要进行拷贝构造的时候也需要拷贝给相同类型的对象所以也要在之前加个const。 构造函数不仅可以构造与初始化对象 对于单个参数或者除第一个参数无默认值其余均有默认值的构造函 数还具有类型转换的作用 。如果我们禁止类型转换我们该如何操作呢 —— explicit关键字 以后我们学到智能指针的时候我们就会用大explicit这个关键字阻止隐式类型转换。 static成员 概念 声明为static的类成员称为类的静态成员用static修饰的成员变量称之为静态成员变量用static修饰的 成员函数称之为静态成员函数。 静态成员变量一定要在类外进行初始化。 面试题计算创建多少个类对象 实现一个类计算程序中创建出了多少个类对象。 class A
{
public:A() { _scount; }A(const A t) { _scount; }~A() { --_scount; }static int GetACount() { return _scount; }
private:static int _scount;
};
int A::_scount 0;
void TestA()
{cout A::GetACount() endl;A a1, a2;A a3(a1);cout A::GetACount() endl;
} 这里就很好理解a1,a2俩个对象然后拷贝构造又创建一个对象总共三个对象。 int _scount 0;
class A
{
public:A() { _scount; }A(const A t) { _scount; }~A() { --_scount; }
private://static int _scount;
};A aa0;A Func(A aa)
{cout __LINE__ : _scount endl;return aa;
}int main()
{cout __LINE__ : _scount endl;A aa1;static A aa2;Func(aa1);cout __LINE__ : _scount endl;return 0;
} 那上面的这段代码怎么统计呢 我们来分析一下aa0是全局创建的一个对象那么25行就只创建了一个对象这样也说明了静态局部变量不会提前初始化等到了它才存在。然后19行我创建了aa0aa1和静态成员对象aa2三个对象然后调用函数的时候我们传参的时候也创建一个对象那么总共四个对象。 然后出了作用域之后对象就销毁29行就只有3个对象。 那我们再来感受一下 int _scount 0;
class A
{
public:A() { _scount; }A(const A t) { _scount; }~A() { --_scount; }
private://static int _scount;
};A aa0;void Func()
{static A aa2;cout __LINE__ : _scount endl;
}int main()
{cout __LINE__ : _scount endl;A aa1;Func();Func();return 0;
} 如果有相同函数调用多次静态区的变量只定义一次。所以最后的对象是3次。 但是我们有没有发现_scount的值是可以随意修改的这是全局变量的劣势任何地方都是可以修改的。 那么如何让_scount封装一下呢——就是再类中封装 我们首先要区分一下成员变量和静态成员变量的区别。 成员变量属于每一个类的对象存储在对象里面 int _a1 1; int _a2 2; 静态成员变量——属于类属于类的每一个对象共享。----存储在静态区 static int _scount; 静态成员变量不像成员变量一样成员变量可以在类中定义但是静态成员变量不能再类中定义要再类外面定义。 那我们这里就不能直接获取_scount了一般静态成员变量和静态成员函数是成套出现的所以我们就声明定义了一个静态成员函数来获取对象个数。 静态成员函数——没有this指针指定类域和访问限定符就可以访问 所以静态成员函数不能访问成员因为访问成员需要this指针而静态成员函数没有this指针是无法访问的。 ///int _scount 0;
class A
{
public:A() { _scount; }A(const A t) { _scount; }~A() { --_scount; }//没有this指针指定类域和访问限定符就可以访问static int GetACount() { return _scount; }
private://成员变量属于每一个类的对象存储在对象里面int _a1 1;int _a2 2;//静态成员变量——属于类属于类的每一个对象共享。----存储在静态区static int _scount;
};//全局位置类外面定义
int A::_scount 0;A aa0;void Func()
{static A aa2;cout __LINE__ : A::GetACount() endl;
}int main()
{cout __LINE__ : A::GetACount() endl;A aa1;Func();Func();return 0;
} 相比全局变量静态成员就是用类来封装让数据更规范一些。 特性 1. 静态成员为所有类对象所共享不属于某个具体的对象存放在静态区 2. 静态成员变量必须在类外定义定义时不添加static关键字类中只是声明 3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问 4. 静态成员函数没有隐藏的this指针不能访问任何非静态成员 5. 静态成员也是类的成员受public、protected、private 访问限定符的限制 6.静态成员变量是不能设置缺省值的为什么成员变量可以设置缺省值因为成员变量有初始化列表来接收要么初始化列表来初始化要么缺省值给初始化然后给初始化列表而静态成员变量没有初始化列表所以不能给缺省值。 【问题】(非)静态调用(非)静态 1. 静态成员函数可以调用非静态成员函数吗 我们知道非静态的成员函数需要 this指针静态的成员函数没有this指针所以不能调用。 2. 非静态成员函数可以调用类的静态成员函数吗 我上面说过了 静态成员函数的特性是没有this指针指定类域和访问限定符限定就可以访问。 【1】非静态成员函数在类中调用类的静态成员函数 因为在类中类里面不受类域和访问限定符的限制类里面就是一个大家庭所以调用静态是完全可以的。 【2】非静态成员函数在类外调用类的静态成员函数 这里用 指定类域和访问限定符限定进行访问。就可以调用静态成员函数 学了上面的知识我们可以看看这个题目很好的复习了静态成员变量和静态成员函数的知识。 【题目】累加 求 123...n 要求不能使用乘除法、 for 、 while 、 if 、 else 、 switch 、 case 等关键字及条件判断语句 A? B:C点击链接练一下吧 大家看见这个题目肯定很熟悉但是我们学习了c并且学习了静态成员变量和静态成员函数我们就可以利用我们现在所学的知识进行解题题目也多加限制了条件出题者就是想让我们用sttic成员)来解题。 思路我们累加到n那么我们就创建一个类Sum,然后我们创建n个Sum类对象都知道出了作用域数据就会被销毁全局变量可以随意修改那么我们就可以用静态成员变量来记录值。 记住成员变量在类里声明在类外定义。但是由于静态成员变量是私有的我们就需要一个静态成员函数来获取该值。所以这就照应了为什么静态成员变量和静态成员函数是成套出现的因为静态成员变量需要静态成员函数来获取。 为什么需要静态成员函数 静态成员函数属于类而不是对象。 由于私有静态成员无法类外访问。 有了静态成员函数之后。 在访问私有静态成员时可以在创建对象前通过类的静态成员函数访问静态成员 类里面不受类域和访问限定符的限制类里面就是一个大家庭所以调用静态是完全可以的或者访问私有函数也是可以的所以我们就需要静态成员函数来调用了。 class Sum
{
public:Sum(){_ret_i;_i;}//因为 _ret是私有的那么我们就要用静态成员函数获取_ret的值static int Getret(){return _ret;}
private:static int _i;static int _ret;
};//静态变量在类里声明类外定义
int Sum::_i1;
int Sum::_ret0;class Solution {
public:int Sum_Solution(int n) {Sum a[n];return Sum::Getret();}
}; 友元 友元提供了一种突破封装的方式有时提供了便利。但是友元会增加耦合度(耦合度是俩者的关系破坏了封装所以友元不宜多用。为什么呢我们往下学就知道了。 友元分为友元函数和友元类 友元函数 我们为什么有友元函数呢 问题现在尝试去重载 operator 然后发现没办法将 operator 重载成成员函数。 因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置 。 this 指针默认是第一个参数也就是左操作数了。但是实际使用中cout 需要是第一个形参对象才能正常使用。所以要将 operator 重载成全局函数。但又会导致类外没办法访问成员此时就需要友元来解决。operator 同理。 我们看下面一段代码就知道上面的一段话是什么意思了。 我们来分析一下这段代码ostream是cout的类我们给ostream创建一个对象_cout我们需要_coutd1那么我们要先传的形参是_cout是cout输出流对象,第二个参数是_d1,但是上面的代码中我们知道operator重载成全局函数是非静态的成员函数而C编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数让该指针指向当前对象(函数运行时调用该函数的对象)在函数体中所有“成员变量”的操作都是通过该指针去访问。所以this指针和cout输出流对象争夺位置但是第一个参数还是this指针(指针指向的当前对象),然后第二个参数就成了cout输出流,导致形成了d1cout不符合常规调用。 所以我们该如何改进呢——如果我们要将operator重载成全局函数这是非静态成员函数那么无法访问到类中的私有成员所以这时候我们就引入了友元的知识了。 class Date
{friend ostream operator(ostream _cout, const Date d);
public:Date(int year, int month, int day): _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 endl;return _cout;
}int main()
{Date d1(2003, 10, 5);cout d1 endl;return 0;
} 友元函数可以直接访问类的私有成员它是定义在类外部的普通函数不属于任何类但需要在类的内部声明声明时需要加friend关键字。 说明 : 友元函数可访问类的私有和保护成员但不是类的成员函数 友元函数不能用const修饰 友元函数可以在类定义的任何地方声明不受类访问限定符限制 一个函数可以是多个类的友元函数 友元函数的调用与普通函数的调用原理相同 友元类 友元类的所有成员函数都可以是另一个类的友元函数都可以访问另一个类中的非公有成员。 友元关系是单向的不具有交换性。 比如上述Time类和Date类在Time类中声明Date类为其友元类那么可以在Date类中直接访问Time 类的私有成员变量但想在Time类中访问Date类中私有的成员变量则不行。 class 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类可以访问。 友元关系不能传递。 比如如果B是A的友元C是B的友元则不能说明C时A的友元。 友元关系不能继承在继承位置再给大家详细介绍。 内部类 概念如果一个类定义在另一个类的内部这个内部类就叫做内部类。内部类是一个独立的类它不属于外部类更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。就可以相较于一个工程师给画了一个图纸工程师给另一个家庭一个福利我可以在图纸里画一下你的家里构造不占据空间 注意内部类就是外部类的友元类参见友元类的定义内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。 class A
{
private:static int k;int h;
public:class B // B天生就是A的友元{public:void foo(const A a){cout k endl;//OKcout a.h endl;//OK}};
};
int A::k 1;
int main()
{A::B b;b.foo(A());return 0;
} 特性 1. 内部类可以定义在外部类的public、protected、private都是可以的。 但是如果定义在public中可以用A::访问限定符给B类创建对象然后访问其中的私有成员但如果内部类定义在private中是完全不可以访问任何成员变量和成员函数的是死死封装住的。 特性一内部类定义在public中 内部类是定义在public中的class A
{
private:static int k;int h;
public:class B // B天生就是A的友元{public:B():m(1),n(1){}void foo(){cout m - n endl;}private:int m;int n;};
};int A::k 1;
int main()
{A::B b;b.foo();return 0;
} 特性一内部类定义在private中 是完全不能访问的是任何对象都不可以访问的 2. 注意内部类可以直接访问外部类中的static成员不需要外部类的对象/类名。 3. sizeof(外部类)外部类和内部类没有任何关系。 特性三类大小 class A
{
private:static int k;int h;
public:class B // B天生就是A的友元{public:void foo(){}};
};
int A::k 1;
int main()
{cout sizeof(A) endl;return 0;
} c很少用内部类但是java经常用。 匿名对象 匿名对象可以理解为没有名字的对象。 特性一生命周期 有名对象 -- 生命周期在当前函数局部域 匿名对象 -- 生命周期在当前行 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) {cout Sum_Solution endl;//...return n;}
};int main()
{A aa(1);//有名对象A(2);//匿名对象Solution s1;s1.Sum_Solution(2);//有名调用函数Solution().Sum_Solution(3);//匿名调用函数return 0;
} 我们可以调试看看 调试完32行之后我们发现构造和析构都调用了说明匿名对象生命周期在当前行即构造即析构。 有名对象的生命周期在局部域内。 特性二匿名对象具有常性 A raA(1); 大家看看ra能不能引用匿名对象 报错是不可以的因为 匿名对象是具有常性的 这样就成功了 const AraA(1); 但是加上const不仅仅只是给匿名对象进行引用也会出现一个神奇的结果。 我们上面看到了这里并没有即构造即析构。这里我就要解析一下了。 结论const引用延长匿名对象的生命周期生命周期在当前函数局部域 我们可以这样理解匿名对象没有人用它那么就即用即销毁那么引用的话有人ra需要引用这个匿名对象所以延长了匿名对象的生命周期。通俗易懂的说法 拷贝对象时一些编译器优化 在传参和传返回值的过程中一般编译器会做一些优化减少对象的拷贝这个在一些场景下还是非常有用的。 比如 一个表达式中连续构造拷贝构造可以优化为一个构造隐式类型中连续构造拷贝构造优化为直接构造连续拷贝构造拷贝构造优化为一个拷贝构造一个表达式中连续拷贝构造赋值重载无法优化 你的大部分时间投入到哪里你大概率就会成为怎样的人!
