【C++】构造函数+类型转换+static成员

文章目录

• 1.构造函数的初始化列表
• • 1.1测试
• 2.类型转换
• 3.static成员

1.构造函数的初始化列表

• 之前我们实现构造函数时，初始化成员变量++主要使⽤函数体内赋值++ ，构造函数初始化还有⼀种⽅式，就是++初始化列表++ ，初始化列表的使⽤⽅式是以⼀个冒号开始 ，接着是⼀个以逗号分隔 的数据成员列表，每个"成员变量"后⾯跟⼀个放在括号中的初始值或表达式。

• 每个成员变量在初始化列表中只能出现⼀次，语法理解上初始化列表可以认为是每个成员变量定义初始化的地⽅。

• ++引⽤成员变量，const成员变量，没有默认构造++ 的类类型变量，必须放在初始化列表位置进行初始化 ，否则会编译报错。（原因：这三类必须在定义时初始化，其他都是用对象整体定义），普通成员可以在初始化列表的位置初始化，也可以在构造函数内初始化，所以建议直接使用初始化列表。

• C++11⽀持在成员变量声明的位置给缺省值 ，这个缺省值主要是++给没有显⽰在初始化列表初始化的成员使⽤的++。

• 尽量使⽤初始化列表初始化。

因为那些你不在初始化列表初始化的成员++也会⾛初始化列表++，如果这个成员在声明位置给了缺省值，初始化列表会⽤这个缺省值初始化。

如果你没有给缺省值，对于没有显⽰在初始化列表初始化的++内置类型成员++是否初始化取决于编译器，C++并没有规定，当做没有初始化

对于没显⽰在初始化列表初始化的++⾃定义类型成员++会调⽤这个成员类型的默认构造函数，如果没有默认构造会编译错误。

• 初始化列表中按照成员变量在类中声明顺序进⾏初始化，跟成员在初始化列表出现的的先后顺序⽆关。++建议声明顺序和初始化列表顺序保持⼀致++。

初始化列表总结：1.一般情况下：建议尽量使用初始化列表显示初始化

2.如果没在初始化列表初始化的值，尽量给缺省值

#include<iostream>
using namespace std;
class Time 
{ 
public: 
    Time(int hour)  :_hour(hour)  
    { 
        cout << "Time()" << endl; 
    } 
private: 
    int _hour; 
}; 
class Date 
{ 
public:
    Date(int& x, int year = 1, int month = 1, int day = 1) 
        :_year(year)  
        ,_month(month)  
        ,_day(day)  
        ,_t(12)  
        ,_ref(x)  
        ,_n(1) 
   {
        // error C2512: "Time": 没有合适的默认构造函数可⽤  
        // error C2530 : "Date::_ref" : 必须初始化引⽤  
        // error C2789 : "Date::_n" : 必须初始化常量限定类型的对象  
    } 
    void Print() const 
    { 
        cout << _year << "-" << _month << "-" << _day << endl; 
    } 
private: 
    int _year; 
    int _month; 
    int _day;
    
    Time _t; // 没有默认构造  
    int& _ref; // 引⽤ 
    const int _n; // const   
}; 
int main() 
{ 
    int i = 0; 
    Date d1(i); 
    d1.Print(); 
    return 0;
}

#include<iostream> 
using namespace std; 
class Time 
{ 
public: 
    Time(int hour) 
        :_hour(hour) 
    { 
        cout << "Time()" << endl; 
    } 
private: 
    int _hour; 
}; 
class Date 
{ 
public:  
    Date() 
        :_month(2) 
    {
        cout << "Date()" << endl; 
    } 
    void Print() const 
    {
        cout << _year << "-" << _month << "-" << _day << endl; 
    } 
private: 
    
    // 注意这⾥不是初始化，这⾥给的是缺省值，这个缺省值是给初始化列表的  
    // 如果初始化列表没有显⽰初始化，默认就会⽤这个缺省值初始化  
    int _year = 1; 
    int _month = 1; 
    int _day; 
    Time _t = 1; 
    const int _n = 1;
    int* _ptr = (int*)malloc(12); 
}; 
int main() 
{ 
    Date d1;
    d1.Print(); 
    return 0; 
} 

既用初始化列表，又用函数体的情况（初步的初始化是用初始化列表，更复杂的（例如下面的检查）在函数体内），但是整体都叫初始化

class A
{
pubilc:
    A(int n=10)
        :_a((int*)malloc(sizeof(int)*n))
        ,_size(0)
    {
       //检查
      if(_a==nullptr)
      {
          cout<<"malloc fail"<<endl;
          exit(-1);
      }
          memset(_a,0,sizeof(int)*n);
    }
private:
   int* _a;
   int _size;
};

1.1测试

下⾯程序的运⾏结果是什么（）

A.输出1 1

B.输出2 2

C.编译报错

D.输出1 随机值

E.输出1 2

F.输出2 1

#include<iostream>
using namespace std; 
class A 
{ 
public:  
    A(int a)  
        :_a1(a) 
        , _a2(_a1) 
    {} 
    void Print() 
    {
        cout << _a1 << " " << _a2 << endl; 
    } 
private: 
    int _a2 = 2; 
    int _a1 = 2; 
}; 
int main() 
{ 
    A aa(1); 
    aa.Print(); 
} 

答案选D，因为初始化列表中按照成员变量在类中声明顺序进⾏初始化，先初始化_a2，后初始化 _a1

2.类型转换

引入：

int main()
{
    //强制转换会产生临时变量
    int i=1;
    double d=i;
    
    //临时变量具有常性
    //double& ref=i;加上const 就可以转换了
    const double& ref=i;
    return 0;
}

相关知识也可以看【C++】c++中"引用"的详解

有一定关联才能强制转换

1.++内置类型和内置类型之间转换++：

整型家族之间

整型和浮点，都是表示数据大小

整型和指针之间，指针是地址的编号

浮点数和指针之间，不能转换

2.++内置类型和自定义类型之间++

C++⽀持内置类型隐式类型转换为类类型对象，需要有相关内置类型为参数的构造函数。

3.自定义类型和自定义类型

类类型的对象之间也可以隐式转换，需要++相应的构造函数⽀持++。

• 构造函数前⾯加explicit就不再⽀持隐式类型转换。

#include<iostream>
using namespace std; 
class A 
{
public:
    A(int a1)  
        :_a1(a1) 
    {} 
private: 
    int _a1 = 1; 
    int _a2 = 2; 
};
//加const的原因：可以传const修饰的对象
//也可以传类型转换产生的临时对象（可以看（1）处的代码对比）
void func(cosnt A& aa=1)
{
    .....
}
class Stack
{
public:
  void Push(const A& a)
  {
      //....
  }
};
int main() 
{
    //构造
    A a1(1);
    //隐式类型转换
    //2为参数构造临时对象，临时对象拷贝构造a2-----编译器会优化为直接构造
    A a2=2;
    
    const A& ref1=a1;
    const A& ref2=1;//这种情况不会优化为直接构造
    
    func(a1);
    //可以传常数，本质传的是类型转换产生的临时对象
    func(1);
    
    //（1）
    Stack st1;
    A a3(31);
    st1.Push(a3);
    //相当于
    st1.Push(3);//比上面简单
    return 0;
}

#include<iostream>
using namespace std; 
class A 
{
public:
    // 构造函数explicit就不再⽀持隐式类型转换  
    // explicit A(int a1) 
    A(int a1)  
        :_a1(a1) 
    {} 
    //explicit A(int a1, int a2) 
    A(int a1, int a2)  
        :_a1(a1)  
        , _a2(a2) 
    {}
    void Print() 
    { 
        cout << _a1 << " " << _a2 << endl; 
    } 
    int Get() const 
    { 
        return _a1 + _a2; 
    } 
private: 
    int _a1 = 1; 
    int _a2 = 2; 
}; 
class B 
{ 
public: 
    B(const A& a) 
        :_b(a.Get()) 
    {} 
private: 
    int _b = 0;
};
int main() 
{
    A aa1 = 1;
    aa1.Print();
    const A& aa2 = 1; 
    
    // C++11之后才⽀持多参数转化    
    A aa3 = { 2,2 }; 
    // aa3隐式类型转换为b对象 
    // 原理跟上⾯类似 
    
    B b = aa3; 
    const B& rb = aa3; 
    return 0; 
}

​

3.static成员

• ⽤static修饰的成员变量，称之为静态成员变量，静态成员变量⼀定要在类外进⾏初始化。

• 静态成员变量为所有类对象所共享，不属于某个具体的对象，不存在对象中，存放在静态区（生命周期是全局）。

• ⽤static修饰的成员函数，称之为静态成员函数，静态成员函数没有this指针。

• ++静态成员函数++ 中可以++访问其他的静态成员++ ，但是++不能访问⾮静态++ 的，因为没有this指针。

• ++⾮静态的成员函数，可以访问任意的静态成员变量和静态成员函数++。

• 突破类域和访问类域可以访问静态成员，可以通过类名::静态成员或者对象.静态成员来访问静态成员变量和静态成员函数。

• 静态成员也是类的成员，受public、protected、private访问限定符的限制。

• 静态成员变量不能在声明位置用缺省值初始化，因为缺省值是个构造函数初始化列表的，静态成员变量不属于某个对象，不会用构造函数初始化列表。（所以在类外定义）

特性	静态成员（static）	非静态成员（普通成员）
归属	属于类，所有对象共享	属于单个对象，每个对象独立拥有
内存分配	程序运行时仅分配一份内存	每个对象创建时，都会为其分配内存
访问方式	类名：：成员或者对象.成员	只能通过对象.成员（或指针 -> 成员）
this 指针	无 this 指针（不依赖对象）	有 this 指针（指向当前对象）
生命周期	程序启动到结束	随对象创建而创建、销毁而销毁

// 实现⼀个类，计算程序中创建出了多少个类对象？   
#include<iostream>
using namespace std;
class A 
{ 
public: 
    A()  
    { 
        ++_count;
    } 
    A(const A& t) 
    {  
        ++_count; 
    } 
    ~A() 
    { 
        --_count; 
    } 
    static int GetACount()  
    { 
        return _count;
    } 
private: 
    // 类⾥⾯声明  
    static int _count; 
}; 
// 类外⾯初始化  
int A::_count = 0; 
int main() 
{ 
    A a1, a2; 
    A a3(a1); 
    //两种调用方式都行
    cout << A::GetACount() << endl; 
    cout << a1.GetACount() << endl; 
    
    // 编译报错：error C2248: "A::_count": ⽆法访问 private 成员(在"A"类中声明)  
    //cout << A::_count << endl; 
    return 0; 
} 

求1+2+3+...+n
点击这里跳转原题

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 arr[n];
        return Sum::GetRet(); 
    } 
};

补充：局部static对象，都是在第一次运行到定义位置时才初始化