初始化列表友元嵌套

在类中我们存在构造函数

e.g

class Stack

{

Stack(int capacity = 4)

{

.......

}

private:

int * arr;

int _capacity;

int _num;

};

在学习之前我们要明白为{}中时进行赋值操作,而非真正意义上的初始化,因此对于一些必须要初始化的类型就会出现问题,比如const & 没有默认构造函数的自定义类型

所以我们cpp中专门进行处理 初始化列表 专门用来进行初始化

我在学的时候,就有一个问题,既然这样为什么在一开始设计的时候不直接把初始化列表集成到{}中?

但说白了,首先说结论,逻辑会出现问题.

1.

{} 是一个语法块,他的执行完全是按照代码顺序,而在内存中声明顺序决定的这些成员在内存的先后顺序.

2.

{} 中会出现重复的问题,初始化只能进行一次,语法块中能进行多次赋值操作,会混淆

因此我们要接受初始化列表,他其实是很有作用的

结构:(每两个之间用逗号 ',',最后不用加 ;)

class Stack

{

Stack(int capacity = 4)

:_capacity(capacity) ---初始化列表就是一个专门用来初始化的地方

,i(1)

{

.......

}

private:

int * arr;

int _capacity;

const int i;

int _num;

};

友元

1.友元函数-->解决了外部访问类中private/protected 成员

class Stack

{

friend void Get_capacity(const Stack& st);

Stack(int capacity = 4)

:_capacity(capacity) ---初始化列表就是一个专门用来初始化的地方

,i(1)

{

.......

}

private:

int * arr;

int _capacity;

const int i;

int _num;

};

void Get_capacity(const Stack & st);

这样声明就代表着这个函数是这个类的友元的函数(想象成朋友),可以访问 非public成员.

2.友元类

class Stack1 class Stack2

{{

friend class Stack2;

Stack1(int capacity = 4)Stack2(int capacity = 5)

:_capacity(capacity):_capacity(capacity)

,i(1),i(1)

{{

.............

}}

private:privat:

int * arr;int* arr;

int _capacity;int _capacity;

const int i;const int i;

int _num;int _num;

};};

表示stack 2 中能够调用stack1中的非公开成员,但不是stack1能调用stack2中的非公开成员

嵌套:

class Stack

{

Stack(int capacity = 4)

:_capacity(capacity)

,i(1)

{

.......

}

class S

{

S(int capacity = 4)

:_capacity(capacity)

,i(1)

{

.......

}

private:

int * arr;

int _capacity;

const int i;

int _num;

};

private:

int * arr;

int _capacity;

const int i;

int _num;

};

这里需要特别注意,可以进行类比,你在全局中定义了class stack 就相当于在class stack中定义了class S,所以这两个类完全是独立的类!!!

1.在没有外部类实例的情况下,你无法调用非静态的成员,可以想象成还没有定义,因此在要是想调用外部类的成员时,要创建一个实例,通过这个实例来实现对外部类成员的调用,在调用的功能上时和友元类相同的

#include<iostream>

using namespace std;

class A

{

private:

static int _k;

int _h = 1;

public:

class B // B默认就是A的友元

{

public:

void foo(const A& a)

{

cout << _k << endl; //OK

cout << a._h << endl; //OK

}

int _b1;

};

};

int A::_k = 1;

int main()

{

A::B b;

A aa;

b.foo(aa);

return 0; }

因为这两个可以是作为独立的类,因此A类的大小是 4 ,静态变量,函数都不算作A类的内存大小