C++类和对象下(初始化列表,静态成员,explicit关键字,友元)（下）

cout << wzs::A().GetCount()-1 << endl;

wzs::B b2 = 1;
竟然能这么创建一个对象,这是怎么做到的呢?
• 1
• 2

当某个类的构造函数可以只传入一个参数时,而且这个参数的类型跟我这个内置类型相同的时候
就可以发生这个类类型对象和这个内置类型变量之间的隐式类型转换
下面这个例子能帮大家更好地去理解
class A
{
public:
    构造函数第1种情况:
    A(int val) //单参数构造函数
    :_var1(val)
    {}         
    A(int val1,int val2 = 2,int val3 = 3)//半缺省,且只传一个参数即可完成对象的构造
    :_var1(val1)
    ,_var2(val2)
    ,_var3(val3)
    {}
    A(int val1 = 1,int val2 = 2,int val3 = 3)//全缺省,这个构造函数允许只传一个参数进行构造
    :_var1(val1)
    ,_var2(val2)
    ,_var3(val3)
    {}
  private:
      int _var1;
      int _var2;
      int _var3;
};
它们都允许: A a = 1;
但是当这个内置类型跟我这个参数的类型不匹配时:
例如   A a = nullptr; 这样就无法发生隐式类型转换

zs::A a={2023,11,3};
• 1

#include <vector>
int main()
{
  vector<zs::A> v;
  //当我们在leetcode做OJ题时:
  //1.在没有学习这个知识之前我们平常的做法
  zs::A a(1);
  v.push_back(a);
  //2.学习了匿名对象后 
  v.push_back(zs::A(1));//  这代码写起来爽了很多
  //3.学习了内置类型和自定义类型之间的隐式转换后
  v.push_back(1);//     这代码写起来太爽了,可是只有在构造函数允许只传一个参数的时候才可以啊
  //4.学习了列表初始化隐式类型转换为类类型对象后
  v.push_back({ 2023,11,3 });//   爽飞了  ,而且允许只传一个参数对我无效
  return 0;
}

这里以C类是B类的友元为例
class B
{
  friend class C;//友元声明不受类访问限定符的限制
}
class C
{
   B b;//需要有一个B类的对象
   //然后想要访问B类的成员变量或者成员函数的时候就可以用这个B类的对象.去访问
}

namespace zs
{
class B
{
public:
  friend class C;
private:
  void FuncOfB()
  {
    cout << "private:  FuncOfB()调用" << endl;
  }
  int _bint = 1;
  static int _StaticInt;
};
int B::_StaticInt = 5;
class C
{
  public:
    void SetMemberOfB(int val)
    {
      b._bint = val;
      B::_StaticInt = val;
    }
    void ReadMemberOfB()
    {
      cout << b._bint << endl;
      cout << B::_StaticInt << endl;//只能这样访问
    }
    void ReadFuncOfB()
    {
      b.FuncOfB();
    }
  private:
    int _cint;
    B b;
  };
}
int main()
{
  zs::C c;
  c.SetMemberOfB(100);
  c.ReadMemberOfB();
  c.ReadFuncOfB();
  return 0;
}

namespace zs
{
  //注意:D是外部类,E是内部类.E天生就是D的友元,但是默认情况下D是不能访问E的,除非在E中声明D是E的友元类
  class D
  {
  public:
    class E
    {
    public:
      void GetStaticMemberOfD()
      {
        cout << _StaticInt << endl;
        //yes  这是上述第3条特性:  内部类可以直接访问外部类的static成员,不需要外部类的对象/类名
        //cout << _NonStaticInt << endl;//err  内部类不能直接访问外部类的非static成员
        cout << d._NonStaticInt << endl;//yes  只能用对象.去访问
        //也就是说内部类访问外部类:只不过是静态成员可以直接访问而已,非静态成员的访问跟普通类访问外部类的非静态成员的方法一样
      }
    private:
      zs::D d;
    };
  private:
    static int _StaticInt;
    int _NonStaticInt = 10;
  };
  int D::_StaticInt = 1;
}