一、再谈构造函数

1.1 构造函数体赋值

在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值。

比如说如下日期类的构造函数的初始化：

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;
};

虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称作为类对象成员的初始化，构造

函数体中的语句只能将其称作为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内

可以多次赋值。

1.2 初始化列表初始化

概念：初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个**"成员变量"后面跟一个放在括

号中的初始值或表达式**。

所以我们刚刚的日期类构造函数还能用初始化列表的形式初始化，如下：

//初始化列表
  Date(int year = 1, int month = 1, int day = 1)
  :_year(year)
  ,_month(month)
  ,_day(day)
  {}

写一个最简单的类A示范：

class A
{
public:
  A(int a)
  :_a(a)
  {}
private:
  int _a;
};

注意

1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)

2. 类中包含以下成员，必须放在初始化列表位置进行初始化：

引用成员变量

const成员变量

自定义类型成员（该类没有默认构造函数）

3. 尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。

4. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关。

第四点我们举一个例子：

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 随机值

分析：初始化的顺序是声明的顺序，不是初始化列表中出现的顺序。

而private里是类成员变量的声明，可以看到是_a2先声明，所以在初始化列表里，因为_a1还没被缺省值1赋值，此时_a1是随机值，_a2由_a1初始化，所以也是随机值，而后面的_a1是由1，初始化，所以_a1的值就是1，答案选D。

1.3 explicit关键词

概念：构造函数不仅可以构造与初始化对象，对于单个参数的构造函数，还具有类型转换的作用。用explicit修饰构造函数，将会禁止单参构造函数的隐式转换。

啥是隐式类型转换？

Date d2 = 2022;//构造 + 拷贝构造 -》优化合二为一

举例：

class Date
{
public:
  Date(int year)//构造函数
  :_year(year)
  {
  cout << "Date(int year)" << endl;
  }
  Date(const Date& d)//拷贝构造
  {
  cout << "Date(const Date& d)" << endl;
  }
private:
  int _year;
};
int main()
{
  Date d1(2022);
  //隐式类型转换
  Date d2 = 2022;//构造 + 拷贝构造 -》 优化 合二为一
  const Date& d6 = 2022;//临时变量具有常性，要加const
  //&的不是2022， 是2022的临时变量
  return 0;
}

没加explicit时可以编译通过，调用了三次构造函数，发生了一次隐式类型转换。

在构造函数处加 explicit就通不过，此时构造函数不允许隐式类型转换。

二、static成员

2.1 概念

声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。静态的成员变量一定要在类外进行初始化.

2.2特性

1. 静态成员为所有类对象所共享，不属于某个具体的实例

2. 静态成员变量必须在类外定义，定义时不添加static关键字

3. 类静态成员即可用类名::静态成员或者对象.静态成员来访问

4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员

5. 静态成员和类的普通成员一样，也有public、protected、private3种访问级别，也可以具有返回值.

举例：统计A类型对象创建了多少个

class A
{
public:
  A()
  {
  ++_count1;   
  }
  A(const A& aa)
  {
  ++_count2;
  }
  //成员函数也可以是静态的，static成员函数没有this指针
  static int GetCount1()
  {
//  _a = 0;//不能访问非静态的成员
  //因为没有this指针
  A aa;//这边有this指针，通过对象去访问私有
  aa._a = 0;
  return _count1;
  }
  static int GetCount2()
  {
  return _count2;
  }
private:
  //静态成员变量属于整个类，所以类的所有对象，放在静态区
  static int _count1;//静态的成员变量
  static int _count2;
  int _a;//假设存在一个非静态的成员变量
};
//类外面初始化
A Func(A a)
{
  A copy(a);
  return copy;
}
int A::_count1 = 0;
int A::_count2 = 0;
int main()
{
  cout << a1.GetCount1() << endl;//使用对象也可以调用
  //这时候不是为了传递this指针，而是为了突破类域
  cout << a1.GetCount2() << endl;
  cout << A::GetCount1() << endl;
  cout << A::GetCount2() << endl;
  return 0;
}

总结：

1、静态的成员或者函数不能在初始化列表初始化。

2、static 成员变量的内存既不是在声明类时分配，也不是在创建对象时分配，而是在（类外）初始化时分配。反过来说，没有在类外初始化的 static 成员变量不能使用。

3、static成员函数不被对象所独有，所有对象都能调用static函数。

虚函数是不能使用static关键字

分析：

1、主要原因是，虚函数调用需要this指针，而static函数不需要。

2、从编译的角度来看，static成员函数是在编译时，静态绑定了的，而虚函数是在运行时，动态绑定。

三、C++11成员初始化的新玩法

3.1 概念

C++11支持非静态成员变量在声明时进行初始化赋值，但是要注意这里不是初始化，这里是给声明的成员变量缺省值。

用A类来举例：

class A
{
public:
  A(int a)
  :_a(a)
  {}
private:
  int _a = 10;
};

四、友元

4.1 友元的一个概念

友元分为：友元函数和友元类。

友元的作用：友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。

在软件模块设计中，我们遵循：高内聚，低耦合的一种设计思维。

4.2 友元函数

概念：友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。

注意：

友元函数可访问类的私有和保护成员，但不是类的成员函数。

友元函数不能用const修饰。

友元函数可以在类定义的任何地方声明，不受类访问限定符限制。

一个函数可以是多个类的友元函数。

友元函数的调用与普通函数的调用和原理相同。

class Date; // 前置声明
class Time
{
       //friend class Date; // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成
       //员变量
       friend void Func(const Date& d, const Time& t);
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
{
       friend void Func(const Date& d, const Time& t);
public:
private:
       int _year;
       int _month;
       int _day;
       Time _t;
};
void Func(const Date& d, const Time& t)
{
       cout << d._year << endl;
       cout << t._hour << endl;
}
int main()
{
       Date d;
       Time t;
       Func(d, t);
       return 0;
}

代码里的Date添加前置声明的作用和声明Date是Time类型的友元作用是一样的。

4.3 友元类

概念：

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。

特性：

友元关系是单向的，不具有交换性。

比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。

如果B是A的友元，C是B的友元，则不能说明C时A的友元。

五、内部类

5.1 内部类的概念

如果一个类定义在另一个类的内部，这个内部类就叫做内部类。注意此时这个内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去调用内部类。外部类对内部类没有任何优越的访问权限。

注意：

内部类就是外部类的友元类。注意友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。

特性：

1. 内部类可以定义在外部类的public、protected、private都是可以的。

2. 注意内部类可以直接访问外部类中的static、枚举成员，不需要外部类的对象/类名。

3. sizeof(外部类)=外部类，和内部类没有任何关系。

举例：

class A
{
private:
       static int k;//是属于整个类的
       int h;
public:
       //内部类
       class B //B天生就是A的友元
       {
       public:
              void foo(const A& a)
              {
                      cout << k << endl;
                      cout << a.h << endl;
              }
       private:
              int _b;
       };
       //A不是B的友元
       //void Print(const B& b)
       //{
       //     b._b = 0;
       //}
};
int main()
{
       A aa;
       cout << sizeof(A) << endl;//算这个类型其实是算这个类型定义对象的大小
       A::B bb;
       return 0;
}

内部类应用比较少，了解就行了。

六、练习题和总结

6.1 本节思维导图

解题思路：利用static函数来解决

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];//通过对象去调用
        //也可以指定类域去调用
        return Sum::GetRet();
    }
};

第二题从 :计算日期到天数的转换

思路：最简单的就是用一个数组存储从第一个月到12个月每个月累加起来的天数，就是比较麻烦些。

也要判断当年是不是闰年，如果是闰年，则如果日期超过2月就要在总天数上+1。

#include <iostream>
using namespace std;
int an[13] = {0, 31, 59,90,120, 151, 181, 212, 243, 273,304,334,365};
int main()
{
    int year,month, day;
    cin >> year >> month >> day;
    int n = an[month - 1] + day;
    if(month > 2 && (year % 4 == 0 && year % 100 != 0
                    || year % 400 == 0))
    {
        n += 1;
    }
    cout << n << endl;
    return 0;
}

第三题 :日期差值

思路：复用第二题的代码，计算出两个日期的天数，再求一下两个日期的差值就可以了。

代码如下：

#include<iostream>
using namespace std;
int an[13] = {0, 31, 59,90,120, 151, 181, 212, 243, 273,304,334,365};
//用数组an来存每个月累加起来的天数
int f(int y, int m, int d)
{
    int n = 0;
    n += y * 365 + an[m - 1] + d;
    if(m > 2 && (y % 4 == 0 && y % 100 != 0
                    || y % 400 == 0))
    {
        n += 1;
    }
    return n;
}
int main ()
{
    int year, month, day, x[2];
    for(int k = 0; k < 2; k++)
    {
        scanf("%4d%2d%2d", &year, &month, &day);
        x[k] = f(year, month, day);
    }
    cout << abs(x[1] - x[0]+1) << endl;
    return 0;
}

【C++】类和对象（下）

一、再谈构造函数

1.1 构造函数体赋值

1.2 初始化列表初始化

1.3 explicit关键词

二、static成员

2.1 概念

2.2特性

三、C++11成员初始化的新玩法

3.1 概念

四、友元

4.1 友元的一个概念

4.2 友元函数

4.3 友元类

五、内部类

5.1 内部类的概念

六、练习题和总结

6.1 本节思维导图

6.2 本节相关练习题

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

【C++】类和对象（下）

一、再谈构造函数

1.1 构造函数体赋值

1.2 初始化列表初始化

1.3 explicit关键词

二、static成员

2.1 概念

2.2特性

三、C++11成员初始化的新玩法

3.1 概念

四、友元

4.1 友元的一个概念

4.2 友元函数

4.3 友元类

五、内部类

5.1 内部类的概念

六、练习题和总结

6.1 本节思维导图

6.2 本节相关练习题

热门文章

最新文章

相关课程

相关电子书

相关实验场景