#include <iostream>
using namespace std;
#include <string>



//初始化列表
class Person{
public:
	//传统初始化操作
	Person(int a, int b, int c) {
		m_A = a;
		m_B = b;
		m_C = c;
	}
	

	int m_A;
	int m_B;
	int m_C;
};

void test01() {
	Person p(10,20, 30);

	
	cout << "m_A=" << p.m_A << endl;
	cout << "m_B=" << p.m_B << endl;
	cout << "m_C=" << p.m_C << endl;
}

int main() {

	test01();
	system("pause");

}

#include <iostream>
using namespace std;
#include <string>



//初始化列表
class Person{
public:
	//传统初始化操作
	/*Person(int a, int b, int c) {
		m_A = a;
		m_B = b;
		m_C = c;
	}
	*/

	//初始化列表初始化属性
	Person(): m_A(10),m_B(20),m_C(30){}


	int m_A;
	int m_B;
	int m_C;
};

void test01() {
//	Person p(10,20, 30);

	Person p;
	cout << "m_A=" << p.m_A << endl;
	cout << "m_B=" << p.m_B << endl;
	cout << "m_C=" << p.m_C << endl;
}

int main() {

	test01();
	system("pause");

}

上面两种方式都正常的输出：



不过我们发现第二种的初始化列表写死了，不够灵活，我们怎么才能灵活的赋值

#include <iostream>
using namespace std;
#include <string>



//初始化列表
class Person{
public:
	//传统初始化操作
	/*Person(int a, int b, int c) {
		m_A = a;
		m_B = b;
		m_C = c;
	}
	*/

	//初始化列表初始化属性
	Person(int a, int b, int c): m_A(a),m_B(b),m_C(c){}


	int m_A;
	int m_B;
	int m_C;
};

void test01() {
//	Person p(10,20, 30);

	Person p(30,50,60);
	cout << "m_A=" << p.m_A << endl;
	cout << "m_B=" << p.m_B << endl;
	cout << "m_C=" << p.m_C << endl;
}

int main() {

	test01();
	system("pause");

}

这个初始化值就比较灵活了



 

1.结构体初始化
结构体是常用的自定义构造类型，是一种很常见的数据打包方法。结构体对象的初始化有多种方式，分为顺序初始化、指定初始化、构造函数初始化。假如有如下结构体。
struct A {
	int b;
	int c;
};

（1）顺序初始化因为书写起来较为简约，是我们最常用的初始化方式，但相对于指定初始化，无法变更数据成员初始化顺序，灵活性较差，而且表现形式不直观，不能一眼看出 struct 各个数据成员的值。
A a = {1, 2};

（2）指定初始化（Designated Initializer）实现上有两种方式，一种是通过点号加赋值符号实现，即“.fieldname=value”，另外一种是通过冒号实现，即“fieldname:value”，其中 fieldname 为结构体成员名称 。前者是 C99 标准引入的初始化方式，后者是 GCC 的扩展。遗憾的是有些编译器并不支持指定初始化，比如 Visual C++。
// 点号+赋值符号
A a = {.b = 1, .c = 2};

//冒号
A a = {b:1, c:2};

Linux 内核喜欢用 .fieldname=value 的方式进行初始化，使用指定初始化，一个明显的优点是成员初始化顺序和个数可变，并且扩展性好，比如在结构体非末尾处增加字段时，避免了传统顺序初始化带来的大量修改。
（3）构造函数初始化常见于 C++ 代码中，因为 C++ 中的 struct 可以看作 class，结构体也可以拥有构造函数，所以我们可以通过结构体的构造函数来初始化结构体对象。给定带有构造函数的结构体：
struct A {
	A(int b,int c) {
		this->b=b;
		this->c=c;
	};
	int b;
	int c;
}

那么结构体对象的初始化可以像类对象初始化那样：
A a(1,2);

注意：  struct 如果定义了构造函数的话，就不能用大括号进行初始化了，即不能再使用指定初始化与顺序初始化了。
2.结构体赋值
变量的赋值和初始化是不一样的，初始化是在变量定义的时候完成的，是属于变量定义的一部分，赋值是在变量定义完成之后想改变变量值的时候所采取的操作。还是给定结构体 A：
struct A {
	int b;
	int c;
};

注意： 结构体变量的赋值是不能采用大括号的方式进行赋值的，例如下面的赋值是不允许的。
A a;
a={1,2};	// 错误赋值

下面列出常见结构体变量赋值的方法。
（1）使用 memset 对结构体变量进行置空操作：
// 按照编译器默认的方式进行初始化（如果 a 是全局静态存储区的变量，默认初始化为0，如果是栈上的局部变量，默认初始化为随机值）
A a; 
memset(&a,0,sizeof(a));

（2）依次给每一个结构体成员变量进行赋值：
A a; 
a.b=1;
a.c=2;

（3）使用已有的结构体变量给另一个结构体变量赋值。也就是说结构体变量之间是可以相互赋值的。
A a={1,2};
struct A a1;
a1=a; 				// 将已有的结构体变量赋给a1

初始化与赋值有着本质的区别，初始化是变量定义时的第一次赋值，赋值则是定义之后的值的变更操作，概念上不同，所以实现上也不一样。
参考文献
[1] 2016腾讯春季校园实习招聘技术岗初试(一面)问题汇总（CC++后台）

[2] 结构体初始化

[3] C结构体-designated initializer

[4] C语言结构体声明中冒号的使用（占位符） &　Ｃ结构体的乱序初始化

 我们知道，构造方法是用来初始化类对象的。如果在类中没有显式地声明构造函数，那么编译器会自动创建一个默认的构造函数；并且这个默认的构造函数仅仅在没有显式地声明构造函数的情况下才会被创建创建。

       构造函数与父类的其它成员(成员变量和成员方法)不同，它不能被子类继承。因此，在创建子类对象时，为了初始化从父类中继承来的成员变量，编译器需要调用其父类的构造函数。如果子类的构造函数没有显示地调用父类的构造函数，则默认调用父类的无参构造函数，至于什么事显式调用，在下面会详细说明！关于子类中构造函数的构造原则，总结如下，欢迎大家指导与批评。

         1.父类没有声明构造函数

         (1)子类也没有声明自己的构造函数，则父类和子类均由编译器生成默认的构造函数。

         (2)子类中声明了构造函数(无参或者带参)，则子类的构造函数可以写成任何形式，不用顾忌父类的构造函数。在创建子类对象时，先调用父类默认的构造函数(编译器自动生成)，再调用子类的构造函数。

         2.父类只声明了无参构造函数

         如果子类的构造函数没有显式地调用父类的构造，则将会调用父类的无参构造函数。也就是说，父类的无参构造函数将会被隐式地调用。

         3.父类只声明了带参构造函数

         在这种情况下，要特别注意。因为父类只有带参的构造函数，所以如果子类中的构造函数没有显示地调用父类的带参构造函数，则会报错，所以必需显示地调用。

关于构造函数的显示调用，参见下例。

class animal
{
protected:       //成员变量，声明为protected或者public，这里选择protected
	int height;  //若声明为private，则不能被子类继承访问，会报错
	int weight;
public:
	animal(int height,int weight)   //带参的构造函数
	{
		this->height=height;
		this->weight=weight;
		cout<<"animal的带参构造函数被调用"<<endl;
	}
	virtual ~animal()
	{
		cout<<"animal的析构函数被调用"<<endl;
	}
};
//子类
class fish:public animal
{
public:
	fish():animal(20, 10) //显示调用父类的构造函数
	{
		cout<<"fish的构造函数被调用"<<endl;
	}
	virtual ~fish()
	{
		cout<<"fish的析构函数被调用"<<endl;
	}
};


在子类fish的构造函数中，加上一个冒号(:)，然后加上父类的带参构造函数，这就是父类构造函数的显式调用。这样，在子类的构造函数被调用时，系统就会去调用父类的带参构造函数，从而实现初始化父类的成员变量。运行结果如下：



注意：

如果父类只有带参的构造函数，且该带参的构造函数的参数有默认值，此时在子类中也可以不用显示的调用父类的构造函数。

// 父类的构造函数，改成带有默认值的参数， 这样在子类中就可以不用显示调用了
        animal(int height=19 ,int weight=20)   //带参的构造函数
        {
                this->height=height;
                this->weight=weight;
                cout<<"animal的带参构造函数被调用"<<endl;
        }


 

4.父类同时声明了无参和带参构造函数

         在这种情况下，子类只需要实现父类的一个构造函数即可，不管是无参的还是带参的构造函数。如果子类的构造函数没有显示地调用父类的构造函数(无参或带参)，则默认调用父类的无参构造函数。

//父类
class animal
{
protected:       //成员变量，声明为protected或者public，这里选择protected
	int height;  //若声明为private，则不能被子类继承访问，会报错
	int weight;
public:	
	animal()
	{
		height=0;
		weight=0;
		cout<<"animal的无参构造函数被调用"<<endl;
	}
	animal(int height,int weight)   //带参的构造函数
	{
		this->height=height;
		this->weight=weight;
		cout<<"animal的带参构造函数被调用"<<endl;
	}
	virtual ~animal()
	{
		cout<<"animal的析构函数被调用"<<endl;
	}
};
//子类
class fish:public animal
{
public:
	fish()     //没有显示地调用父类的构造函数(无参或带参)，则默认调用父类的无参构造函数
	{
		cout<<"fish的构造函数被调用"<<endl;
	}
	virtual ~fish()
	{
		cout<<"fish的析构函数被调用"<<endl;
	}
};


运行结果如下：



总结以上几条，可以归纳出C++中子类继承父类时构造函数的写法的规律：当父类有显式地声明了构造函数时，子类最低限度的实现父类中的一个；当父类没有声明构造函数时，子类可以不声明构造函数或者任意地书写构造函数。

在训练神经网络之前，必须对其全值和偏置进行初始化。常用的初始化方法有四种，分别是高斯初始化、Xavier初始化和MSRA初始化。它们一般都把偏置初始化为0，但对权值进行随机初始化。其中，高斯初始化比较容易理解，就是根据某个高斯分布来初始化权值，但均值通常选0，方差需要按经验人工选择。下面对Xavier和MSRA以及He做进一步的说明。

Xavier的基本思想是保持信息在神经网络中流动过程的方差不变。假设激活函数是关于0点对称的，且主要针对于全连接神经网络，适应于tanh和softsign。这种方法在实际应用时根据一个均匀分布来初始化权值。如果某个神经元 有  个输入  ,相应的连接权值为  ，则满足关系：



那么采用Xavier进行初始化的方法就是：



MSRA的基本思想与Xavier类似，但主要是针对ReLU和PReLU激活函数来设计的。这种方法在实际应用时根据一个方差为 的零均匀高斯分布来初始化权值，即



He的基本思想是正向传播时，状态值的方差保持不变；反向传播时，关于激活值的梯度的方差保持不变。

适用于ReLU的初始化方法：



适用于Leakly ReLU的初始化方法：



在darknet中CNN的权值初始化采用He的方法，具体实现见源码。后续我们会在【darknet源码解析】系列中详细讲解其实现。

完，