文章目录
 
1.结构体初始化
2.结构体赋值
参考文献

 
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
 
初始化与赋值有着本质的区别，初始化是变量定义时的第一次赋值，赋值则是定义之后的值的变更操作，概念上不同，所以实现上也不一样。
 
 
参考文献
 
2016腾讯春季校园实习招聘技术岗初试(一面)问题汇总（CC++后台）
 结构体初始化
 C结构体-designated initializer
 C语言结构体声明中冒号的使用（占位符） &　Ｃ结构体的乱序初始化

定义
 
struct InitMember
{
    int first；
    double second；
    char* third；
    float four;
};
 
方法一：定义时赋值
 
struct InitMember test = {-10,3.141590，"method one"，0.25}；
 
需要注意对应的顺序，不能错位。
 
方法二：定义后逐个赋值
 
struct InitMember test；

test.first = -10;
test.second = 3.141590;
test.third = "method two";
test.four = 0.25;
 
因为是逐个确定的赋值，无所谓顺序啦。
 
方法三：定义时乱序赋值（C风格）
 
这种方法类似于第一种方法和第二种方法的结合体，既能初始化时赋值，也可以不考虑顺序；
 
struct InitMember test = {
    .second = 3.141590,
    .third = "method three",
    .first = -10,
    .four = 0.25
};
 
这种方法在Linux内核（kernel）中经常使用，在音视频编解码库FFmpeg中也大量频繁使用，还是很不错的一种方式。
 
方法四：定义时乱序赋值（C++风格）
 
这种方法和前一种类似，网上称之为C++风格，类似于key-value键值对的方式，同样不考虑顺序。
 
struct InitMember test = {
    second：3.141590,
    third："method three",
    first：-10,
    four：0.25
};
 
写在后面
 
其实问题的引出是在分析FFmpeg源代码时，发现大量的结构体乱序赋值初始化的方式，以前在C语言教材上没有发现这种用法，于是学习总结一下，放到这里存档。

#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.pytorch自定义网络结构不进行参数初始化会怎样，参数值是随机的吗？
 
2.如何自定义参数初始化？
 
先回答第一个问题
 
在pytorch中，有自己默认初始化参数方式，所以在你定义好网络结构以后，不进行参数初始化也是可以的。
 
1.Conv2d继承自_ConvNd，在_ConvNd中，可以看到默认参数就是进行初始化的，如下图所示
 
 
 
 
2.torch.nn.BatchNorm2d也一样有默认初始化的方式
 
 
3.torch.nn.Linear也如此
 
 
现在来回答第二个问题。
 
pytorch中对神经网络模型中的参数进行初始化方法如下：
 
from torch.nn import init
#define the initial function to init the layer's parameters for the network
def weigth_init(m):
    if isinstance(m, nn.Conv2d):
        init.xavier_uniform_(m.weight.data)
        init.constant_(m.bias.data,0.1)
    elif isinstance(m, nn.BatchNorm2d):
        m.weight.data.fill_(1)
        m.bias.data.zero_()
    elif isinstance(m, nn.Linear):
        m.weight.data.normal_(0,0.01)
        m.bias.data.zero_()
 
  首先定义了一个初始化函数，接着进行调用就ok了，不过要先把网络模型实例化：
 
  #Define Network
    model = Net(args.input_channel,args.output_channel)
    model.apply(weigth_init)
 
 此上就完成了对模型中训练参数的初始化。
 
 在知乎上也有看到一个类似的版本，也相应的贴上来作为参考了：
 

def initNetParams(net):
    '''Init net parameters.'''
    for m in net.modules():
        if isinstance(m, nn.Conv2d):
            init.xavier_uniform(m.weight)
            if m.bias:
                init.constant(m.bias, 0)
        elif isinstance(m, nn.BatchNorm2d):
            init.constant(m.weight, 1)
            init.constant(m.bias, 0)
        elif isinstance(m, nn.Linear):
            init.normal(m.weight, std=1e-3)
            if m.bias:
                init.constant(m.bias, 0)
 
initNetParams(net)
 
再说一下关于模型的保存及加载
 
1.保存有两种方式，第一种是保存模型的整个结构信息和参数，第二种是只保存模型的参数
 
 #保存整个网络模型及参数
 torch.save(net, 'net.pkl') 

 #仅保存模型参数
 torch.save(net.state_dict(), 'net_params.pkl')
 
2.加载对应保存的两种网络
 
# 保存和加载整个模型  
torch.save(model_object, 'model.pth')  
model = torch.load('model.pth')  
 
# 仅保存和加载模型参数  
torch.save(model_object.state_dict(), 'params.pth')  
model_object.load_state_dict(torch.load('params.pth'))