目录
一,初始化列表
二,static成员
三,C++11的成员初始化新玩法
四,友元
五,内部类
一,初始化列表
构造函数体赋值
//类A
class A
{
public:
A(int a = 1)
{
_a = a;
cout << "A(int a = 1)" << endl;
}
A& operator = (const A& a)
{
if (this != &a)
_a = a._a;
cout << "A& operator = (const A& a)" << endl;
return *this;
}
private:
int _a;
};
//类B
class B
{
public:
B(int a, int b)
{
_b = b;
_aa = A(a); //A(a)为匿名函数,生命周期只在这一行
}
private:
int _b;
A _aa;
};
int main()
{
B b(10, 20);
return 0;
}
初始化列表
class B
{
public:
B(int a, int b)
:_aa(a)
{
_b = b;
}
private:
int _b;
A _aa;
};
注:
class B
{
public:
B(int a, int b1, int& b2)
:_aa(a)
,_b1(b1)
,_b2(b2)
{}
private:
const int _b1;
int& _b2;
A _aa;
};
explicit 关键字
class A
{
public:
A(int a)
:_a(a)
{
cout << "A(int a = 1)" << endl;
}
A(const A& a)
{
cout << "A(const A& a)" << endl;
}
private:
int _a;
};
int main()
{
A a1(1);
//先1构造一个临时对象,在拷贝构造给a2,最终vs编译器优化为直接用1构造a2
A a2 = 1; //本质是有个隐式类型转换,int->A
return 0;
}
二,static成员
声明为static的类成员,称为类的静态成员:
特性:
class A
{
public:
int _a;
//静态成员变量
static int _count;
};
//需类外定义,且无需static关键字
int A::_count = 1;
int main()
{
A a;
//访问形式
A::_count;
a._count;
return 0;
}
class A
{
public:
void print()
{
cout << "print" << endl;
}
//静态成员函数
static int Get()
{
//print(); 不可调用
return _count;
}
private:
int _a;
static int _count;
};
int A::_count = 1;
int main()
{
A a;
//访问形式
A::Get();
a.Get();
return 0;
}
三,C++11的成员初始化新玩法
C++11支持非静态成员变量,在声明时进行初始化赋值,但要注意这里不是初始化,是给声明的成员变量缺省值;
class A
{
public:
A(int a = 0)
{
_a = a;
}
private:
int _a = 10;
};
class B
{
private:
//非静态成员变量,可在成员声明时给缺省值
int _b = 20;
int* p = (int*)malloc(sizeof(int)*10);
A _a = 20; //单参数,有个隐式转换
//静态成员不在构造函数初始化,要在类外定义初始化
//static int _n = 10;
};
四,友元
友元提供了一种突破封装的方式,但友元会增加耦合度,破坏了封装,所以友元不宜多用;
分类:
友元函数
可直接访问类的私有成员,是定义在类外部的普通函数,不属于任何类,但需要在类的内部声明;声明时加friend关键字;
class A
{
//友元函数
friend void print(const A& a);
public:
A(int a)
:_a(a)
{}
private:
int _a = 10;
};
//类外定义的普通函数,需类内部声明且添加fiend关键字
void print(const A& a)
{
cout << a._a << endl;
}
int main()
{
A a(1);
print(a);
return 0;
}
class B; //前置声明
class A
{
friend void print(const A& a, const B& b);
public:
A(int a)
:_a(a)
{}
private:
int _a = 10;
};
class B
{
friend void print(const A& a, const B& b);
public:
B(int b)
:_b(b)
{}
private:
int _b = 10;
};
//一个函数可以有多个类的友元函数
void print(const A& a, const B& b)
{
cout << a._a << endl;
cout << b._b << endl;
}
int main()
{
A a(1);
B b(2);
print(a, b);
return 0;
}
友元类
友元类的所有成员函数都可以是另一个类的友元函数,都可以访问另一个类中的非公有成员;
class A
{
friend class B;
private:
int _a = 10;
};
class B
{
public:
void print(const A& a)
{
cout << a._a << endl;
}
private:
int _b = 20;
};
int main()
{
A a;
B b;
b.print(a);
return 0;
}
五,内部类
如一个类定义在另一个类的内部,此内部的类就叫做内部类;此时这个内部类是一个独立的类,不属于外部类,更不能通过外部类的对象去调用内部类;外部类对内部类没有任何优越的访问权限;
内部类就是外部类的友元类;注意友元类的定义,内部类可通过外部类的对象参数访问外部类中的所有成员,但外部类不是内部类的友元;
特性:
class A
{
private:
int _a = 10;
public:
class B
{
public:
//内部类,天生是A的友元
void print(const A& a)
{
cout << a._a << endl;
}
private:
int _b = 20;
};
};
int main()
{
A a;
//受外部类类域即访问限定符限制
A::B b;
b.print(a);
return 0;
}