类
class A {
public:
A() {a=10;b=a;} // 错误,没有进行初始化,只进行了赋值,由于const和引用都需要初始化,所以错误
A():b(a),a(10){} // 正确,初始化顺序是成员函数声明顺序,先b后a
A():a(10),b(a){} // 有时错误,有的编译器不认可不按声明顺序的初始化
void f(){cout<<a<<" "<<b<<endl;}
private:
constint &b;
constint a;
};
class B {
public:
B(int i1,int i2):a(i1),b(i2){} // 正常构造函数
B(int i3):B(i3,10){a=i3+1;} // 构造函数委托了上一个构造函数
B():B(50){b=15;} // 默认构造函数委托了上一个构造函数,执行顺序如下:a=50,b=10; a=51,b=10;
a=51,b=15;
void f(){cout<<a<<" "<<b<<endl;}
private:
int a;
int b;
};
class C {
public:
C(int i){a=i;} // 这里定义了构造函数,覆盖了默认构造函数
private:
int a;
};
class D {
public:
D(){}
C c; // 编译错误,因为c没有默认构造函数,无法初始化 D d也是错误的,最好都提供默认构造函数
};
class A {
public:
explicit A(int i):a(i){} // 构造函数,前面加explicit表示禁止通过此构造函数执行隐式类型转换,只有单形参的构造函数可以类型转换,explicit只会加在这类函数前
A(std::string s):a(2){} // 没有加explicit,所以可以类型转换
void f(){cout<<a<<endl;}
private:
int a;
};
class B {
public:
void f(A a){a.f();} // f中可以传入A类型对象,也可以传入一个字符串,进行默认类型转换
};
class C {
public:
int a; // 聚合类:所有都是public 没有构造函数 没有类内初始化
std::string b;
void f(){cout<<a<<" "<<b<<endl;}
};
int main() {
B b;
b.f(1); // 错误,f(int)是explicit的,不能将1转化成A
b.f(A(1)); // 正确,显示定义了A temp(1); f(temp);无视explicit,explicit只限制默认转换
b.f(static_cast<A>(1)); // 正确,强制类型转换无视explicit
std::string s="abc"; // 正确,b.f(s)由string默认转换成A
b.f(s);
b.f("abc"); // 错误,默认转换只允许一步,这里是两步string temp="abc";f(temp);多了一步从const char*转化成string。另外,string类的string(const char*)构造函数不是explicit的,所以使用string的地方,都可以用"abc"常量代替;而vector类的vector(int);是expicit的,不允许使用int代替vector;
C c = {1,"abc"}; // 聚合类的初始化
C c2 = {"abc",1}; // 必须按照形参声明顺序
c.f();
return0;
}
class A {
public:
void h(){a++;cout<<a<<endl;} // 定义类的非静态方法,静态成员是和类一起诞生的,在对象出现之前,所以非静态方法可以调用静态成员
static void j(); // 声明类的静态方法
private:
static int a; // 声明类的静态成员
int b; // 声明类的非静态成员
};
int A::a = 10; // 类的静态成员必须在类外进行初始化,初始化时不加static,static只出现在类内
void A::j() { // 静态方法也是不加static
a++;
b++; // 错误,静态方法中不可以调用非静态成员,因为此时对象没有初始化,非静态成员没有定义
cout<<a<<endl;
}
int main() {
A::j(); // 11 静态成员调用不必初始化对象,使用类调用或者对象调用
A a;
a.h(); // 12 对象可以调用静态和非静态成员
a.j(); // 13
return 0;
}