• 结构体初始化
千次阅读 多人点赞
2021-06-02 09:26:46

一、介绍
结构体作为数据结构的基础，经常使用，其中初始化也有几种方法，这里详细介绍

二、常规初始化（先定义再初始化）

typedef struct {
int bandrate;
int databits;
int stopbits;
int parity;
int dtr;
}serial_hard_config_def;

serial_hard_config_def serial;
serial.bandrate = 115200;
serial.databits = 8;
serial.stopbits = 1;
serial.parity = 0;
serial.dtr = 0;


三、定义的同时初始化
1、顺序初始化

typedef struct {
int bandrate;
int databits;
int stopbits;
int parity;
int dtr;
}serial_hard_config_def;

serial_hard_config_def serial = {
115200,
8,
1,
0,
0
};



2、乱序初始化

typedef struct {
int bandrate;
int databits;
int stopbits;
int parity;
int dtr;
}serial_hard_config_def;

serial_hard_config_def serial = {
.dtr = 0,
.bandrate = 115200,
.databits = 8,
.stopbits = 1,
.parity = 0,
};


3、结构体数组初始化

typedef struct {
int bandrate;
int databits;
int stopbits;
int parity;
int dtr;
}serial_hard_config_def;

serial_hard_config_def serial[2] = {
[0] = {
.dtr = 0,
.bandrate = 115200,
.databits = 8,
.stopbits = 1,
.parity = 0,
},
[1] = {
.dtr = 0,
.bandrate = 115200,
.databits = 8,
.stopbits = 1,
.parity = 0,
}
};


4、嵌套结构体初始化

typedef struct {
int bandrate;
int databits;
int stopbits;
int parity;
int dtr;
}serial_hard_config_def;

typedef struct {
serial_hard_config_def hardware;
int model;

}serial_config_def;

serial_config_def serial_config = {
{
.dtr = 0,
.bandrate = 115200,
.databits = 8,
.stopbits = 1,
.parity = 0,
},
.model = 1
}


5、嵌套结构体数组初始化

typedef struct {
int bandrate;
int databits;
int stopbits;
int parity;
int dtr;
}serial_hard_config_def;

typedef struct {
serial_hard_config_def hardware;
int model;

}serial_config_def;

serial_config_def serial_config[2] = {
[0] = {
{
.dtr = 0,
.bandrate = 115200,
.databits = 8,
.stopbits = 1,
.parity = 0,
},
.model = 1,
},
[1] = {
{
.dtr = 0,
.bandrate = 115200,
.databits = 8,
.stopbits = 1,
.parity = 0,
},
.model = 1,
}
}

更多相关内容
• 在C++里可以将结构体看作没有任何成员函数的对象，下面对C++结构体的几种初始化方法进行总结。

在 C++ 里可以将结构体看作没有任何成员函数的对象，下面对 C++ 结构体的几种初始化方法进行总结。

# 直接赋值

#include <bits/stdc++.h>
using namespace std;
struct Date
{
int year;
double month;
string day;
};

int main()
{
// 第1种方法
Date date1;
date1.year = 2022;
date1.month = 7.0;
date1.day = "22";
cout<<date1.year<<" "<<date1.month<<" "<<date1.day<<endl;

// 第2种方法
Date date2 = {2022, 7.0, "22"}; // 顺序赋值
cout<<date2.year<<" "<<date2.month<<" "<<date2.day<<endl;
return 0;
}


如果只是想全部初始化为 0 可以按照如下方法

#include <bits/stdc++.h>
using namespace std;
struct Date
{
int year;
double month;
string day;
};

int main()
{
// 第一种方法
Date date1 = {}; // 初始完后字符串为空串
cout<<date1.year<<" "<<date1.month<<" "<<date1.day<<endl; // 0 0

// 第二种方法 （注意只有0能将所有变量初始化为0，使用其他数字只能将第一个数初始化为1其他仍为0）
Date date2 = {0}; // 初始完后字符串为空串
cout<<date2.year<<" "<<date2.month<<" "<<date2.day<<endl; // 0 0
return 0;
}


结构体包含数组（数组在结构体变量定义完就初始化为0）

#include <bits/stdc++.h>
using namespace std;
struct Date
{
int year;
double month;
string day;
int a[10];
};

int main()
{
Date date2 = {2022, 7.0, "22", {1}}; // 顺序赋值
cout<<date2.year<<" "<<date2.month<<" "<<date2.day<<" "<<date2.a[0]<<" "<<date2.a[1]<<endl; //2022 7 22 1 0
return 0;
}



# 利用函数赋值

直接赋值的方法虽然很直观，但是如果需要初始化多个结构体变量，那么代码量为很多且很冗余，而顺序赋值的方式会因为参数过多而容易出错，因此我们可以利用函数来为结构体变量赋值。

#include <bits/stdc++.h>
using namespace std;
struct Date
{
int year;
double month;
string day;
int a[10];
};

Date init( int year, double month, string day)
{
Date temp;
temp.year = year;
temp.month = month;
temp.day = day;
memset(a, 0, sizeof(a)); // 需要memst进行初始化，不然a数组不会被初始化为0
return temp;
}
int main()
{
Date date = init(2022, 7.0, "22");
cout<<date.year<<" "<<date.month<<" "<<date.day<<" "<<date.a[0]<<endl; // 2022 7 22 0
return 0;
}



需要注意的是，结构体=结构体是浅拷贝，简单变量没问题，动态分配的变量会出问题。

# 构造函数初始化

引言提到，在 c++ 中可以将结构体看作没有任何成员函数的对象，因此也可以使用构造函数进行初始化。

#include <bits/stdc++.h>
using namespace std;
struct Date
{
int year;
double month;
string day;
int a[10];
Date()
{
year = 2022;
month = 7.0;
day = "22";
}
Date(int year) //这里可以使用 Date(int year=0) 来指定year默认值，但是这样就不能有Date()
{
this->year = year;
month = 7.0;
day = "22";
}
};

int main()
{
// 默认值初始化
Date date1;
cout<<date1.year<<" "<<date1.month<<" "<<date1.day<<" "<<date1.a[0]<<endl; // 2022 7 22 0

// 指定一个值
Date date2(2022);
cout<<date2.year<<" "<<date2.month<<" "<<date2.day<<" "<<date2.a[0]<<endl; // 2022 7 22 0
return 0;
}



当然除了指定一个 year， 我们也可以指定 month、day 等，这里就不详细展开了。
我们可以用冒号操作来简化构造函数的写法。

#include <bits/stdc++.h>
using namespace std;
struct Date
{
int year;
double month;
string day;
int a[10];
Date() : year(2022),month(7.0),day("22"){}
Date(int year) : year(year),month(7.0),day("22") {}//这里可以使用 Date(int year=0) 来指定year默认值，但是这样就不能有Date()
};

int main()
{
// 默认值初始化
Date date1;
cout<<date1.year<<" "<<date1.month<<" "<<date1.day<<" "<<date1.a[0]<<endl; // 2022 7 22 0

// 指定一个值
Date date2(2022);
cout<<date2.year<<" "<<date2.month<<" "<<date2.day<<" "<<date2.a[0]<<endl; // 2022 7 22 0
return 0;
}


展开全文
• C语言结构体初始化教程在C语言结构体初始化语法struct structName varName = {fileldValue1, fileldValue2, fileldValue3};参数参数描述struct结构体的关键字。structName结构体名。varName结构体变量名。...

C语言结构体初始化教程

C语言结构体初始化

语法

struct structName varName = {fileldValue1, fileldValue2, fileldValue3};

参数

参数

描述

struct

结构体的关键字。

structName

结构体名。

varName

结构体变量名。

fileldValue1

结构体第一个字段对应的初始化值。

fileldValue2

结构体第二个字段对应的初始化值。

fileldValue3

结构体第三个字段对应的初始化值。

说明

我们分别使用了 fileldValue1 来初始化了结构体 varName 中的第一个字段的值，使用了 fileldValue2 来初始化了结构体 varName 中的第二个字段的值，fileldValue3 来初始化了结构体 varName 中的第三个字段的值。

使用这种方式初始化，我们只能按照顺序一个个的初始化结构体的成员。

C语言初始化结构体成员

语法

struct structName varName = {

.filed1 = value1,

.filed2 = value2,

.filed3 = value3

};

说明

我们分别使用了 value1 来初始化了结构体 varName 中的 filed1 字段，使用了 value2 来初始化了结构体 varName 中的 filed2 字段，value3 来初始化了结构体 varName 中的 filed3 字段。

使用这种方式初始化，我们可以按照任意的顺序初始化结构体的成员。

注意

使用这种方式初始化结构体成员使用的是 .filed1 = value1 的形式，且除了最后一个成员，其他的每一个成员的最后都要加一个逗号，即 ,。

最后一个成员不可以加逗号。

C语言初始化结构体成员

语法

struct structName varName = {

filed1 : value1,

filed2 : value2,

filed3 : value3

};

说明

我们分别使用了 value1 来初始化了结构体 varName 中的 filed1 字段，使用了 value2 来初始化了结构体 varName 中的 filed2 字段，value3 来初始化了结构体 varName 中的 filed3 字段。

使用这种方式初始化，我们可以按照任意的顺序初始化结构体的成员。

注意

使用这种方式初始化结构体成员使用的是 filed1 : value1 的形式，且除了最后一个成员，其他的每一个成员的最后都要加一个逗号，即 ,。

最后一个成员不可以加逗号。

案例

C语言顺序初始化结构体成员

顺序初始化结构体中的成员

#include

struct Car{

char *brand;

int price;

int maxSpeed;

};

void main(){

printf("嗨客网(www.haicoder.net)\n\n");

struct Car car = {"Benz", 100000, 256};

char *brand = car.brand;

int price = car.price;

int maxSpeed = car.maxSpeed;

printf("Init Brand = %s, Price = %d, MaxSpeed = %d\n", brand, price, maxSpeed);

}

程序运行后，控制台输出如下图所示：

我们首先，定义了一个结构体 Car，该结构体有三个成员，即一个

接着，我们使用了顺序初始化的方式，初始化了结构体 car 的三个成员，即分别将结构体 car 的 brand 字段初始化为 “Benz”、结构体 car 的 price 字段初始化为 100000、结构体 car 的 maxSpeed 字段初始化为 256。

C语言乱序初始化结构体成员

乱序初始化结构体中的成员

#include

struct Car{

char *brand;

int price;

int maxSpeed;

};

void main(){

printf("嗨客网(www.haicoder.net)\n\n");

struct Car car = {

.price = 900000,

.maxSpeed = 400,

.brand = "Benz"

};

char *brand = car.brand;

int price = car.price;

int maxSpeed = car.maxSpeed;

printf("Init Brand = %s, Price = %d, MaxSpeed = %d\n", brand, price, maxSpeed);

}

程序运行后，控制台输出如下图所示：

这次，我们在结构体里面，通过 “.FileldName” 的形式初始化了结构体的成员，使用这种方式初始化结构体的成员，不需要按照顺序，只需要在前面写上我们需要初始化的字段名即可。

最后，我们使用

C++风格结构体初始化

使用 C++ 风格来初始化结构体成员

#include

struct Car{

char *brand;

int price;

int maxSpeed;

};

void main(){

printf("嗨客网(www.haicoder.net)\n\n");

struct Car car = {

price : 900000,

maxSpeed : 400,

brand : "Benz"

};

char *brand = car.brand;

int price = car.price;

int maxSpeed = car.maxSpeed;

printf("C++ Style Init Brand = %s, Price = %d, MaxSpeed = %d\n", brand, price, maxSpeed);

}

程序运行后，控制台输出如下图所示：

这次，我们使用了 C++ 风格来初始化了结构体的成员。

C语言结构体初始化总结

在 C 语言中，我们要初始化一个结构体，有三种方法，即，顺序初始化、乱序初始化和 C++ 风格的初始化。

展开全文
• c语言中交换两个结构体的值（结构体指针） 1关于语言的结构体： 首先我们为什么要用到结构体，我们都已经学了很多int char …等类型还学到了同类型元素构成的数组，以及取上述类型的指针，在一些小应用可以灵活...

## 1.关于c语言的结构体:

首先我们为什么要用到结构体，我们都已经学了很多int char …等类型还学到了同类型元素构成的数组，以及取上述类型的指针，在一些小应用可以灵活使用，然而，在我们实际应用中，每一种变量进行一次声明，再结合起来显然是不太实际的，类如一位学生的信息管理，他可能有，姓名（char），学号（int）成绩（float）等多种数据。如果把这些数据分别单独定义，就会特别松散、复杂，难以规划，因此我们需要把一些相关的变量组合起来，以一个整体形式对对象进行描述，这就是结构体的好处。

2首先我们要了解一些小知识

2.1**只有结构体变量才分配地址，而结构体的定义是不分配空间的。**
2.2结构体中各成员的定义和之前的变量定义一样，但在定义时也不分配空间。
2.3结构体变量的声明需要在主函数之上或者主函数中声明，如果在主函数之下则会报错
2.4c语言中的结构体不能直接进行强制转换，只有结构体指针才能进行强制转换
2.5相同类型的成员是可以定义在同一类型下的
列如


struct Student
{
int number,age；//int型学号和年龄
char name[20],sex;//char类型姓名和性别
float score;
}；


最后的分号不要忘了 有的编译器会自动加上，因此有的同学就会不注意。

3关于结构体变量的定义和引用

在编译时，结构体的定义并不分配存储空间，对结构体变量才按其数据结构分配相应的存储空间


struct Book
{
char title[20];//一个字符串表

示的titile 题目
char author[20];//一个字符串表示的author作者
float value;//价格表示
};//这里只是声明 结构体的定义
struct Book book1,book2;//结构体变量的定义 分配空间

book1.value;//引用结构体变量


定义结构体变量以后，系统就会为其分配内存单元，比如book1和book2在内存中占44个字节（20+20+4）具体的长度你可以在你的编译器中使用sizeof关键字分别求出来。
列如

当然，要注意一点：用sizeof关键字求结构体长度时，返回的最大基本类型所占字节的整数倍 比方说我们上面求得的为44 为 float(4个字节)的整数倍，
但是我们把title修改为title[22]; 这时正常长度为46 ，但是你会发现实际求得的为48，(4的整数倍)

这就涉及到结构体的存储

1结构体整体空间是占用空间最大的成员（的类型）所占字节数的整数倍。

2.结构体的每个成员相对结构体首地址的偏移量(offset)都是最大基本类型成员字节大小的整数倍，如果不是编译器会自动补齐，

关于这个我们简单介绍下：

1.偏移量----偏移量指的是结构体变量中成员的地址和结构体变量首地址的差。即偏移字节数，结构体大小等于最后一个成员的偏移量加上他的大小，第一个成员的偏移量为0，

struct S1
{
char a;

int b;

double c;
};


这里char a 偏移量为1 之后为int b 因为偏移量1不为int(4)的整数倍，所以会自动补齐，而在 double c 时，偏移量为8 是double(8)的整数倍，所以不用自动补齐 最后求得结构体得大小为 16

具体看下图：

通过上面的代码同学们应该会有一个简单的认知

4结构体变量的初始化

结构体的初始化有很多需要注意的地方，这里我们说明下
首先是几种初始化的方法
ps在对结构体变量初始化时，要对结构体成员一一赋值，不能跳过前面成员变量，而直接给后面成员赋初值，但是可以只赋值前面几个，对与后面未赋值的变量，如果是数值型，则会自动赋值为0,对于字符型，会自动赋初值为NULL，即‘\0’

4.1定义时直接赋值

struct Student
{
char name[20];
char sex;
int number;
}stu1={"zhaozixuan",'M',12345};
//或者
struct Student
{
char name[20];
char sex;
int number;
}；
struct Student stu1={"zhaozixuan",'M',12345};



注意字符为‘ ’ 字符串为""
4.2定义结构体之后逐个赋值

stu1.name="王伟"；
stu1.sex='M';
stu1.number=12305;
//也可用strcpy函数进行赋值
strcpy(stu1.name,"王伟");



4.3定义之后任意赋值

 struct Student stu1={
.name="Wang",
.number=12345,
.sex='W',
};//可以对任意变量赋值


这样写的好处时不用按照顺序来进行初始化，而且可以对你想要赋值的变量直接进行赋值，而不想赋值的变量可以不用赋值

需要注意的是如果在定义结构体变量的时候没有初始化，那么后面就不能全部一起初始化了；

等下结构体数组初始化时我们还会有一个讲解

这里我们顺带提一下typedef说明结构体类型

这里的BOOK就相当于struct book的一个别名一样，用它来定义结构体变量非常简便
主要也是考二级要用到，所以我们简单介绍下

5结构体变量的引用（输出和输入）

5.1结构体变量的赋值用scanf赋值和printf输出时跟其他变量操作一样
但是有几点需要注意
(1) .是运算符，在所有运算符优先级中最高
(2)如果结构体的成员本身是一个结构体，则需要继续用.运算符，直到最低一级的成员。

struct Student
{	char name[20];
char sex;
int number;
struct Date
{
int year;
int month;
int day;
}birthday;

}stu1;
printf("%d",stu1.birthday);//这样子是错误的，因为birthday也是一个结构体变量
scanf("%d",&stu1.birthday.month);//正确


(3)可以引用接头体变量成员的地址，也可以引用结构体变量的地址：

printf("%o", student);(输出student的首地址)(%o 按八进制输出)

6结构体数组及其初始化(重点)

这里我们简单说下，具有相同类型的结构体变量组成数组就是结构体数组

结构体数组与结构体变量区别只是将结构体变量替换为数组

struct Student
{
char name[20];
char sex;
int number;
}stu1[5]={
{"zhaozixuan",'M',12345},
{"houxiaohong",'M',12306},
{"qxiaoxin",'W',12546},
{"wangwei",'M',14679},
{"yulongjiao",'W',17857}
};
stu1[3].name[3]//表示stu1的第三个结构变量中姓名的第五个字符
//若初始化时已经是结构体数组全部元素[]中的数可以不写如stu1[]=


注意结构体数组要在定义时就直接初始化，如果先定义再赋初值是错误的
比如：

struct Student stu1；
stu1[3]={
{"zhaozixuan",'M',12345},
{"houxiaohong",'M',12306},
{"qxiaoxin",'W',12546}
};



这样子是错误的，

这里我在写的时候遇到一些问题，还是结构体数组初始化的问题，折腾了下解决了，给大家分享下
对于数组初始化时
比如

char str[20];
str="I love you";/* 这样会修改数组的地址，但是数组的地址分配之后是不允许改变的 */



在第一条语句中 str就已经被定义成数组而在C99标准中不允许将字符串(实际上是一个指针变量) 赋值给数组，所以如果我们直接赋值是错误的

那么怎么弄呢
这里提供3种方法

1.定义数组时直接定义
char str[20]=“I love you”;

2.用strcpy或者memset函数进行复制
char str[20];
strcpy(str,“I love you”);
再用到memset函数时，出现了一些问题
对于memcset函数简单介绍下

memset
void *memset(void *s,int c,size_t n)
作用：将已开辟内存空间s的首n个字节的值设为值c。

char str[20];
memset(str,'a',20);


如果是字符类型数组的话，memset可以随便用，但是对于其他类型的数组，一般只用来清0或者填-1，如果是填充其他数据就会出错

int str[10];
memset(str,1,sizeof(str));//这样是错误的



这里我们说下这个错误，

首先我们要知道memset在进行赋值时，是按字节为单位来进行赋值的，每次填充的数据长度为一个字节，而对于其他类型的变量，比如int，占4个字节 所以sizeof(str)=40； 而用memset赋值时，将会对指向str地址的前40个字节进行赋值0x01（00000001） 的操作，把0x00000000赋值4次0x01操作变为0x01010101（00000001000000010000000100000001）

相当于给“前10个int”进行了赋值0x01010101的操作 对应十进制的16843009
所以会出很大的错误

这里请务必要注意，但是如果是清零一个数组用memset还是很方便的
简单使用的话同学们用strcmp函数就行

3用指针（注意内存分配）
char *str；
str=“I love you”;

这两句话的本质是，在内存中开辟一段内存空间，把"I love you"放进这段内存空间，然后把这段内存空间的地址交给str，由于str是变量，所以给它赋值是合法的。

请注意，在我们进行数组初始化的时候如果定义的数组过长，而我们只初始化了一部分数据，对于未初始化的数据如果是数值型，则会自动赋值为0,对于字符型，会自动赋初值为NULL，即‘\0’ 即不足的元素补以默认值
这里我们在4小节中也提到了
比如

int str[10]={1};//这里只是把str的第一个元素赋值为1，其他元素默认为0



7结构体与指针

我们知道，指针指向的是变量所占内存的首地址，在结构体中，指针指向的是结构体变量的起始地址，当然也可指向结构体变量的元素
这里我们分为三部分
7.1指向结构体变量的指针

定义形式一般为
struct 结构体名* 指针名；
比如： struct Student* p；

struct Student
{
char cName[20];
int number;
char csex;
}student1;
struct Student*p;
p=&student1;
//若为结构体数组则
struct Student stu1[5];
struct Student*p;
p=stu1;//因为stu1为结构体数组而p=stu1直接是指向stu1的首地址，就不用再加&符



用结构体指针变量访问结构体变量成员有以下两种方式：
(*p).cName //这里的括号不能少，在5.1中有提到
p->cName

简单来说以下三种形式是等价的

p->cName
(*p).cName
student1.cName
p->cName //可以进行正常的运算


p->number++; 是将结构体变量中number的值进行运算，然后再加一，
这里要注意下，等下在7.2中会有比较

7.2指向结构体数组的指针

7.1中我们已经提到结构体数组指针的命名，这里我们仅对一些知识点做下介绍
这里我们接着来说结构体数组指针
在我们想要用指针访问结构体数组的第n个数据时可以用

struct Student stu1[5];
struct Student*p;
p=stu[n];
(++p).number//是指向了结构体数组下一个元素的地址



7.3结构体成员是指针类型变量
比如

struct Student
{
char* Name;//这样防止名字长短不一造成空间的浪费
int number;
char csex;
}student1;



在使用时可以很好地防止内存被浪费，但是注意在引用时一定要给指针变量分配地址，如果你不分配地址，结果可能是对的，但是Name会被分配到任意的一的地址，结构体不为字符串分配任何内存存储空间具有不确定性，这样就存在潜在的危险，

struct Student
{
char* Name;
int number;
char csex;
}stu，*stu；

stu.name=(char*)malloc(sizeof(char));//内存初始化


这里我们说一下，同学们看书的时候一般不会看到，
如果我们定义了结构体指针变量，他没有指向一个结构体，那么这个结构体指针也是要分配内存初始化的，他所对应的指针类型结构体成员也要相应初始化分配内存

struct Student
{
char* Name;
int number;
char csex;
}stu,*stu;
stu = (struct student*)malloc(sizeof(struct student));./*结构体指针初始化*/
stu->name = (char*)malloc(sizeof(char));/*结构体指针的成员指针同样需要初始化*/



7.4二叉树遍历算法
二叉树的二叉链表类型定义如下：
typedef struct btnode {
datatype data;
struct btnode *lchild,*rchild;
}；
这里我们仅仅提出以下，因为涉及到链表，感兴趣的同学可以去学习下（二级要用），
7.5结构体作为函数参数

首先我们要注意的一点，使用结构体变量作为函数参数的时候，采取的是值传递的方式，将结构体所占内存单元的内容全部传递给形参，并且形参必须也要是同类型的结构体变量，在使用时，会自动创建一个结构体变量作为原变量的副本，并且也需要占内存，并且在调用期间如果修改（形参）结构体中成员的值，修改值是无效的

而如果用指针作为实参，传递给函数的形参，这时候传递的是结构体的地址，形参所指向的地址就是结构体变量的地址，这时候进行修改的话是可以修改的，这正是指针的精华所在

在这里我们再提供几种互换两个结构体的方法

struct Student
{
char cName[20];
int number;
char csex;
}student1,student2;
struct Student student1={"Wang",12345,'W'};
struct Student student2={"Zhao",54321,'M'};
struct Student*stu1=&student1;
struct Student*stu2=&student2;

struct Student *student3;
student3=stu1;
stu1=stu2;
stu2=student3;//互换地址

2对于同类型结构体直接互换值就行
struct stu student3;
student3=student1;
student1=student2;
student2=student3;
//这里也可以写成应strcmp函数互换

3用memcpy()函数进行互换

4比较笨的方法： 用for循环互换


最后提下memset清空结构体

struct Student
{
char cName[20];
int number;
char csex;
}stu1;

一般情况下，清空str的方法：
str.cName[0]='\0';
str.csex='0';
str.number=0;
但是我们用memset就非常方便：
memset(&str,0,sizeof(struct Student));
如果是数组：
struct Student stu[10];
就是
memset(stu,0,sizeof(struct Student)*10);


整理不易，点个赞再走呗！

展开全文
• 在GUN C中，支持通过标号元素来对指定结构体成员名进行初始化，这允许初始化值以任意顺序出现。 在内核中对初始化时有如下代码。 其中对进行了两次赋值，第一次是，而最后，又使用宏对其进行了赋值，那结果如何呢？ ...
• 结构体初始化的四种方法 从事嵌入式开发后开始使用C来编程。刚开始觉得非常拧巴，经常阅读C代码也就慢慢习惯了。由于没有类的概念，结构体在C中大量使用，今天聊聊结构体变量初始化的四种方法。 C语言中结构体初始化...
• 1.先定义再初始化 struct obj_t { const char *name; int val; }; obj_t obj; obj.name = "ABC"; obj.val = 0; 2.定义的时候初始化 // 写法1 按照顺序赋值 struct { const char *name; int val; } obj_2 = {...
• 在实际问题中，一组数据可能具有不同的数据类型。假设要存储班上同学的信息，我们需要存储他（她）的姓名、性别、学号。我们希望有一种数据格式将所有信息存储到一个单元中。...而C++中的结构体可以满足要求。......
• 转载： 结构体初始化小技巧
• ## 结构体初始化方法

千次阅读 2021-02-21 12:48:32
C语言结构体初始化的四种方法 定义 struct InitMember { int first； double second； char* third； float four; }; 方法一：定义时赋值 struct InitMember test = {-10,3.141590，"method one"，0.25}； 1 ...
• 文章目录指定结构体初始化器(Designated Initializers)背景初始化struct初始化union对于重复初始化的说名 本人就职于国际知名终端厂商，负责modem芯片研发。 在5G早期负责终端数据业务层、核心网相关的开发工作，...
• } 运行结果： 如果想初始化结构体数组，可采用 {{ }, { }, { }} 方式，如 struct student_st stus[2] = { { .c = 'D', .score = 94, /*也可以只初始化部分成员*/ }, { .c = 'D', .score = 94, .name = "Xxx" }, };
• 某日在看Linux底层驱动的介绍时，发现在Linux C中结构体的有多种初始化方式，这激起了我的好奇心，亲自实践，今日便来总结一下。首先定义一个结构体：structtest{inta;char;};在Linux C中可以这样初始化：...
• new初始化结构体指针 可以通过使用new关键字对结构体进行实例化，得到的是结构体的地址。 格式如下： package main import "fmt" type stu struct { name,address string } func main() { // 结构体指针1 var ...
• 嵌套结构体初始化的几种方式 #结构体定义 structA define typedef struct { char a; int b; float c; }struct_A_s; 1 2 3 4 5 6 structB define typedef struct { char a; int b; struct_A_s ...
• 构造函数是用来初始化结构体的一种函数，它直接定义在结构体中。它不需要写返回值类型，而且函数名和结构体名相同。 我们在定义结构体时，系统会自动生成一个构造函数，但是这个构造函数不需要传入任何参数。我们...
• 在C++11之前，只能对结构体或类的静态常量成员进行就地初始化，其他的不行。 class C { private: static const int a=10; //yes int a=10; //no } 在C++11中，结构体或类的数据成员在申明时可以直接赋予一个...
• memset可以方便的清空一个结构类型的变量或数组。如： 　struct sample_struct 　{ 　char csName[16]; 　int iSeq; 　int iType; 　}; 对于变量 struct sample_strcut stTest; 一般情况下，清空stTest的...st...
• 结构体是常用的自定义构造类型，是一种很常见的数据打包方法。
• 定义 struct InitMember { int first；... 写在后面 其实问题的引出是在分析FFmpeg源代码时，发现大量的结构体乱序赋值初始化的方式，以前在C语言教材上没有发现这种用法，于是学习总结一下，放到这里存档。
• 使用“键值对”初始化结构体 type People struct { name string child *People } relation := &People{ name: "爷爷", child: &People{ name: "爸爸", child: &People{ name: "我", }, }, } ...
• 1、直接对整个结构体进行初始化： struct stu xiaoming = {"xiaoming",10}; 2、通过结构体的各个元素进行单独初始化： struct stu xiaowang; strcpy(xiaoming.name,"xiaoming"); xiaoming.age = 10; 3、通过另...
• C语言 - 数组与结构体初始化方法与区别 说明 本文的测试均在VS2015的开发环境下测试。 数组与结构体初始化方法 假设结构体为： struct Node { int a; int b; int c; }; 1.定义变量后，再初始化 int array[5]; ...
• C99中对结构体初始化部分改动比较多，支持部分数据赋值，语法如下所示： 1.声明结构体类型 typedef struct { int a; char b; float c; }Demo_TypeDef; 2.结构体定义及初始化 Demo_TypeDef Demo = { .a = ...
• 一、结构体基本初始化方法 定义 struct Mystruct { int first; double second; char* third; float four; }; 1、方法一：定义时赋值 赋值时注意定义时各个成员的顺序，不能错位。 struct Mystruct test ...
• ## C++/Qt结构体初始化

千次阅读 2019-10-15 10:11:59
结构体初始化我们经常会用到，使用未初始化的结构体，结果是不可预估的 下面介绍几种常用的结构体初始化方式： 1、结构体内分别初始化 typedef struct stTemp { int nName; int nType; char arrayTemp[50]; ...
• C语言结构体初始化 定义： struct 结构体名 { //成员列表 类型名 成员名 } //变量列表 使用 “.” ,调用结构体各项成员，完成基本操作 结构体数组初始化 #include&lt;iostream&gt; using ...
• 在golang当中结构体初始化的方法有四种。 new关键字 我们可以通过new关键字来创建一个结构体的实例，这种方法和其他语言比较类似，这样会得到一个空结构体指针，当中所有的字段全部填充它类型对应的零值。比如

...