目录
求1+2+3+...+n_牛客题霸_牛客网 (nowcoder.com)
必须在初始化列表初始化的条件：
1：const修饰的成员变量（只有一次初始化的机会，发生在定义的时候，也就是初始化列表
2：引用：（要变成其他变量的别名，只有一次初始化的机会，发生在定义，也就是初始化列表。
3：自定义类型成员（且该类没有默认构造）
例如：
#include<iostream>
using namespace std;
class A
{
public:
A(int a)
{
_a = a;
}
private:
int _a;
};
class B
{
public:
B()
{
}
private:
int _b;
A a;
};
我们不运行也会报错 ：如果没有在初始化列表中写的话，对于自定义类型A会调用其默认构造，因为类A没有默认构造，所以报错。
总结：
explicit
class Date
{
public:
Date(int year)
:_year(year)
{}
Date& operator=(const Date&d)
{
if (this != &d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
return *this;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2022);
Date d2 = 2022;
return 0;
}
隐式类型转换。
类比这里：
把整型i传递给一个临时变量，该临时变量的类型是double，再把该临时变量赋值给d。
这里也是同样，把2022强制类型转换为Date类型传递给临时变量，再把该临时变量传递给d5.
这里无法优化：这里是引用，必须用2022先构造一个对象，再用该对象引用。
explicit Date(int year)
:_year(year)
{}我们在构造函数前面加上了explicit，就不会发生这些隐式类型转换：
Date(int year,int month=1,int day=1)
:_year(year)
, _month(month)
, _day(day)
{}这种半缺省，只用传一个参数的也支持隐式类型转换。
全缺省的也可以。
多参数强制类型转换
class Date
{
public:
Date(int year,int month,int day)
:_year(year)
, _month(month)
, _day(day)
{}
Date& operator=(const Date&d)
{
if (this != &d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
return *this;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
/*Date d1(2022);
Date d2 = 2022;
const Date&d5 = 2022;*/
Date d1 = { 2022, 10, 12 };
Date d2(2022, 10, 12);
return 0;
}
int main()
{
/*Date d1(2022);
Date d2 = 2022;
const Date&d5 = 2022;*/
Date d1 = { 2022, 10, 12 };
Date d2(2022, 10, 12);
const Date&d3 = { 2022, 10, 13 };
return 0;
}静态成员
class A
{
public:
A(int a = 0)
:_a(a)
{
;
}
private:
int _a;
};
int main()
{
A aa1(1);
A aa2 = 2;
return 0;
}我们想要计算一共创建了多少个A类的对象。
int N = 0;
class A
{
public:
A(int a = 0)
:_a(a)
{
+ +N;
}
A(const A&aa)
:_a(aa._a)
{
++N;
}
private:
int _a;
};
int main()
{
A aa1(1);
A aa2 = 2;
cout << N << endl;
return 0;
}只有构造和拷贝构造可以创建对象：
int N = 0;
class A
{
public:
A(int a = 0)
:_a(a)
{
++N;
}
A(const A&aa)
:_a(aa._a)
{
++N;
}
private:
int _a;
};
int main()
{
A aa1(1);
A aa2 = 2;
A aa3 = aa1;
cout << N << endl;
return 0;
}
int N = 0;
class A
{
public:
A(int a = 0)
:_a(a)
{
++N;
}
A(const A&aa)
:_a(aa._a)
{
++N;
}
private:
int _a;
};
void f(A aa)
{
}
int main()
{
A aa1(1);
A aa2 = 2;
A aa3 = aa1;
cout << N << endl;
f(aa1);
cout << N << endl;
return 0;
}
验证了传值传参就是拷贝构造。
int N = 0;
class A
{
public:
A(int a = 0)
:_a(a)
{
++N;
}
A(const A&aa)
:_a(aa._a)
{
++N;
}
private:
int _a;
};
void f(A aa)
{
}
A f1()
{
A aa;
return aa;
}
int main()
{
A aa1(1);
A aa2 = 2;
A aa3 = aa1;
cout << N << endl;
f(aa1);
cout << N << endl;
f1();
cout << N << endl;
return 0;
}
传值返回也是一次拷贝构造。
尽量避免使用全局变量：
全局变量在哪里都可以修改。
类里的静态受到类域的限制。
#include<iostream>
using namespace std;
class A
{
public:
A(int a=1)
:_a(a)
{
;
}
private:
int _a;
static int N;
};
int main()
{
A aa1(1);
A aa2 = 2;
A aa3 = aa1;
}aa1和aa2中有静态成员变量N吗？
总结：静态成员变量不存在于类对象里，存在于静态区。
对于静态成员变量需要在构造函数里初始化吗？
答：不需要，因为静态成员变量是每一个对象都共享的，每一次构造都对静态成员都会对静态成员变量进行修改。
静态成员变量的定义：
在全局定义，需要加上类域。
只能在类里面使用静态成员变量。
静态成员变量的生命周期是全局的，作用域受类域限制
当静态成员变量是公有的时候，也是可以在类外面访问的
#include<iostream>
using namespace std;
int A::N = 0;
class A
{
public:
A(int a=1)
:_a(a)
{
N++;
}
private:
int _a;
public:
static int N;
};
int main()
{
A aa1(1);
A aa2 = 2;
A aa3 = aa1;
cout << A::N << endl;
cout << aa1.N << endl;
}对于静态成员变量为私有的情况，设置一个成员函数取出静态成员变量。
int GetN()
{
return N;
}静态成员函数：
如果我们想得到静态成员变量，使用静态成员函数没有对象也可以调用。
静态成员函数只能访问静态成员（没有this指针）
题目1：
求1+2+3+...+n_牛客题霸_牛客网 (nowcoder.com)
class Sum
{
public:
Sum()
{
_ret+=_add;
_add++;
}
static int GetRet()
{
return _ret;
}
private:
static int _ret;
static int _add;
};
int Sum::_ret=0;
int Sum::_add=1;
class Solution {
public:
int Sum_Solution(int n) {
Sum A[n];
return Sum::GetRet();
}
};要求类对象只能在栈上：
class A
{
public:
A(int a =0)
:_a(a)
{
}
private:
int _a;
};
class A
{
public:
A GetObj(int a = 0)
{
A aa(a);
return aa;
}
private:
A(int a =0)
:_a(a)
{
}
private:
int _a;
};
int main()
{
A aa3 = GetObj();
return 0;
}我们要调用函数GetObj，就需要先创建对象，我们要创建对象，就得先调用函数，产生矛盾。
class A
{
public:
static A GetObj(int a = 0)
{
A aa(a);
return aa;
}
private:
A(int a =0)
:_a(a)
{
}
private:
int _a;
};
int main()
{
A aa3 = A::GetObj();
return 0;
}我们可以用静态函数，静态函数不需要对象也可以调用。
