1、结构体

结构体是用户自定义的数据类型,允许用户存储不同的数据类型;在结构体中可以为不同项定义不同的数据类型。

C++ 结构体

语法:

struct 结构体名 { 结构体成员列表 };

三种定义结构体变量方式:

  1.  [struct]  结构体名  变量名 (可省略struct)
  2.  [struct]  结构体名  变量名 = { 成员1值, 成员2值 ...... }  (可省略struct)
  3.  定义结构体时创建变量
#include<iostream>
#include<string>
using namespace std;

//结构体定义
//人类
struct Person
{
	//姓名
	string name;
	//性别
	string sex;
	//年龄
	int age;
} s3; //第三种创建结构体变量:结构体变量在定义时创建

//结构体成员输出
void print(Person s)
{
	cout << "s1结构体:姓名:" << s.name << ", 性别:" << s.sex << ", 年龄:" << s.age << endl;
}

int main()
{
	//第一种创建结构体变量:[struct]  结构体名  变量名; (可省略struct)
	struct Person s1;

	//成员赋值
	s1.name = "Tracy";
	s1.sex = "女";
	s1.age = 20;

	//成员输出
	print(s1);

	//第二种创建结构体变量: [struct]  结构体名  变量名 = { 成员1值, 成员2值 ...... }  (可省略struct)
	Person s2 = { "Felix", "男", 16 };

	//成员输出
	print(s2);


	//第三种创建结构体变量:见结构体定义处
	//成员赋值
	s3.name = "Timo";
	s3.sex = "女";
	s3.age = 60;

	//成员输出
	print(s3);

	system("pause");

	return 0;
}

 输出结果

s1结构体:姓名:Tracy, 性别:女, 年龄:20
s2结构体:姓名:Felix, 性别:男, 年龄:16
s3结构体:姓名:Timo, 性别:女, 年龄:60

Go语言结构体

语法:

type 结构体名 struct { 结构体成员列表 } 

三种定义结构体变量方式:

  1. var 变量名 结构体名
  2. 变量名 := 结构体名{ 成员1值, 成员2值 ...}
  3. 变量名 := 结构体名{ 成员名1:值1,成员名2:值2,... }
package main

import "fmt"

//人类
type Person struct {
	//姓名
	name string
	//性别
	sex string
	//年龄
	age int
}

func main() {
	//第一种创建结构体变量:var 变量名 结构体名
	var s1 Person

	//成员赋值
	s1.name = "Tracy"
	s1.sex = "女"
	s1.age = 20

	//成员输出
	print(s1)

	//第二种创建结构体变量:变量名 := 结构体名{ 成员1值, 成员2值 ...}
	s2 := Person{ "Felix", "男", 16 }

	//成员输出
	print(s2)

	//第三种创建结构体变量:变量名 := 结构体名{ 成员名1:值1,成员名2:值2,... }
	s3 := Person{
		name: "Timo",
		age: 60,
		sex: "女",
	}

	//成员输出
	print(s3)
}

//结构体成员输出
func print(s Person) {
	fmt.Printf("s1结构体:姓名:%s, 性别:%s, 年龄:%d\n", s.name, s.sex, s.age)
}

 输出结果

s1结构体:姓名:Tracy, 性别:女, 年龄:20
s1结构体:姓名:Felix, 性别:男, 年龄:16
s1结构体:姓名:Timo, 性别:女, 年龄:60

2、结构体数组

C++结构体数组

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

//结构体定义
//人类
struct Person
{
	//姓名
	string name;
	//性别
	string sex;
	//年龄
	int age;
};

int main()
{
	//结构体数组变量定义并初始化
	struct Person s[3] = {
		{ "Felix", "男", 16 },
		{ "Tracy", "女", 20 },
		{ "Timo", "男", 60 }
	};

	//结构体数组元素赋值
	s[0].age = 17;

	//成员输出
	for (int i = 0;i < 3;i++) {
		cout << "s结构体数组:姓名:" << s[i].name << ", 性别:" << s[i].sex << ", 年龄:" << s[i].age << endl;
	}

	system("pause");

	return 0;
}

输出结果

s结构体数组:姓名:Felix, 性别:男, 年龄:17
s结构体数组:姓名:Tracy, 性别:女, 年龄:20
s结构体数组:姓名:Timo, 性别:男, 年龄:60

Go语言结构体数组

package main

import "fmt"

//人类
type Person struct {
	//姓名
	name string
	//性别
	sex string
	//年龄
	age int
}

func main() {
	//结构体数组变量定义并初始化
	var s [3]Person = [3]Person{
		{ "Felix", "男", 16 },
		{ "Tracy", "女", 20 },
		{ "Timo", "男", 60 },
	}

	//结构体数组元素赋值
	s[0].age = 17

	//成员输出
	for i := 0; i < 3; i++ {
		fmt.Printf("s结构体数组:姓名:%s, 性别:%s, 年龄:%d\n", s[i].name, s[i].sex, s[i].age)
	}
}

输出结果 

s结构体数组:姓名:Felix, 性别:男, 年龄:17
s结构体数组:姓名:Tracy, 性别:女, 年龄:20
s结构体数组:姓名:Timo, 性别:男, 年龄:60

3、 结构体指针

C++结构体指针

通过操作符 -> 访问结构体中的成员。

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

//结构体定义
//人类
struct Person
{
	//姓名
	string name;
	//性别
	string sex;
	//年龄
	int age;
};

int main()
{
	//结构体指针
	Person* s  = new Person;
	cout << "s结构体指化针变量初始化值:" << s << endl;
	cout << "s结构体指化针变量初始化成员值:姓名:" << s->name << ", 性别:" << s->sex << ", 年龄:" << s->age << endl;

	//结构体指针元素赋值
	s->name = "Tracy";
	s->sex = "female";
	s->age = 20;

	//成员访问输出
	cout << "s结构体指针:姓名:" << s->name << ", 性别:" << s->sex << ", 年龄:" << s->age << endl;

	system("pause");

	return 0;
}

输出结果

s结构体指化针变量初始化值:000001A95760DAB0
s结构体指化针变量初始化成员值:姓名:, 性别:, 年龄:-842150451
s结构体指针:姓名:Tracy, 性别:female, 年龄:20

Go语言结构体指针

结构体指针与结构体值类型一样,通过操作符 . 访问结构体中的成员。

package main

import (
	"fmt"
)

//人类
type Person struct {
	//姓名
	name string
	//性别
	sex string
	//年龄
	age int
}

func main() {
	//结构体指针
	var s *Person
	fmt.Println("s结构体指针变量初始值:", s)

	//使用new初始化结构体指针
	s = new(Person)
	fmt.Println("s结构体指化针变量初始化值:", s)
	//初始化后结构体成员为成员类型的零值
	fmt.Printf("s结构体指化针变量初始化成员值:姓名:%s, 性别:%s, 年龄:%d\n", s.name, s.sex, s.age)

	//成员赋值
	s.name = "Tracy"
	s.sex = "女"
	s.age = 20

	//成员访问输出
	fmt.Printf("s结构体指针:姓名:%s, 性别:%s, 年龄:%d\n", s.name, s.sex, s.age)
}

 输出结果

s结构体指针变量初始值: <nil>
s结构体指化针变量初始化值: &{  0}
s结构体指化针变量初始化成员值:姓名:, 性别:, 年龄:0
s结构体指针:姓名:Tracy, 性别:女, 年龄:20

4、结构体嵌套 

C++结构体嵌套

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

//结构体定义

//人类
struct Person
{
	//姓名
	string name;
	//性别
	string sex;
	//年龄
	int age;
};

//员工
struct Employee
{
	//人类结构体
	Person person;
	//职位
	string position;
};

int main()
{
	//结构体嵌套
	Employee employee;

	//成员属性赋值
	employee.person.name = "Tracy";
	employee.person.sex = "女";
	employee.person.age = 20;
	employee.position = "软件开发工程师";

	//成员访问输出
	cout << "员工姓名:" << employee.person.name
		<< "性别:" << employee.person.sex
		<< "年龄:" << employee.person.age
		<< "职位:" << employee.position << endl;

	system("pause");

	return 0;
}

输出结果

员工姓名:Tracy性别:女年龄:20职位:软件开发工程师

Go语言结构体嵌套

package main

import "fmt"

//人类
type Person struct {
	//姓名
	name string
	//性别
	sex string
	//年龄
	age int
}

//员工
type Employee struct {
	//人类结构体
	person Person
	//职位
	position string
}

func main() {
	var employee = Employee{
		person: Person{
			name: "Tracy",
			sex: "女",
			age: 20,
		},
		position: "软件开发工程师",
	}

	//成员访问输出
	fmt.Printf("员工姓名:%v, 性别:%v, 年龄:%v, 职位:%v",
		employee.person.name, employee.person.sex, employee.person.age, employee.position)
}

输出结果

 员工姓名:Tracy, 性别:女, 年龄:20, 职位:软件开发工程师

5、结构体作为参数

结构体作为参数可以值传递,也可以地址传递。

C++ 结构体作为参数

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

//结构体定义
//人类
struct Person
{
	//姓名
	string name;
	//性别
	string sex;
	//年龄
	int age;
};

//结构体作为值参数传递
void printPerson(Person s)
{
	cout << "结构体值参数传递:姓名:" << s.name 
		<< ", 性别:" << s.sex 
		<< ", 年龄:" << s.age << endl;
	s.name = "Tracy";
}

//结构体作为地址参数传递
void printPerson(Person *s)
{
	cout << "结构体地址参数传递:姓名:" << s->name 
		<< ", 性别:" << s->sex 
		<< ", 年龄:" << s->age << endl;
	s->name = "Tracy";
}

int main()
{
	//结构体作为参数传递
	Person person = { "Felix", "男", 16 };

	//值参数传递
	printPerson(person);
	cout << "结构体值参数传递后成员无变化:姓名:" << person.name 
		<< ", 性别:" << person.sex 
		<< ", 年龄:" << person.age << endl;

	//地址参数传递
	printPerson(&person);
	cout << "结构体值参数传递后成员有变化:姓名:" << person.name
		<< ", 性别:" << person.sex
		<< ", 年龄:" << person.age << endl;

	system("pause");

	return 0;
}

输出结果

结构体值参数传递:姓名:Felix, 性别:男, 年龄:16
结构体值参数传递后成员无变化:姓名:Felix, 性别:男, 年龄:16
结构体地址参数传递:姓名:Felix, 性别:男, 年龄:16
结构体值参数传递后成员有变化:姓名:Tracy, 性别:男, 年龄:16

Go语言结构体作为参数

package main

import "fmt"

//人类
type Person struct {
	//姓名
	name string
	//性别
	sex string
	//年龄
	age int
}

func main() {
	//结构体作为参数传递
	person := Person{ "Felix", "男", 16 }

	//值参数传递
	printPerson(person)
	fmt.Printf("结构体值参数传递:姓名:%s, 性别:%s, 年龄:%d\n",
		person.name, person.sex, person.age)

	//地址参数传递
	printPerson2(&person)
	fmt.Printf("结构体地址参数传递:姓名:%s, 性别:%s, 年龄:%d\n",
		person.name, person.sex, person.age)

}

//结构体作为值参数传递
func printPerson(s Person) {
	fmt.Printf("结构体值参数传递后成员无变化:姓名:%s, 性别:%s, 年龄:%d\n", s.name, s.sex, s.age)
	s.name = "Tracy"
}

//结构体作为地址参数传递
func printPerson2(s *Person) {
	fmt.Printf("结构体值参数传递后成员有变化:姓名:%s, 性别:%s, 年龄:%d\n", s.name, s.sex, s.age)
	s.name = "Tracy"
}

输出结果

结构体值参数传递后成员无变化:姓名:Felix, 性别:男, 年龄:16
结构体值参数传递:姓名:Felix, 性别:男, 年龄:16
结构体值参数传递后成员有变化:姓名:Felix, 性别:男, 年龄:16
结构体地址参数传递:姓名:Tracy, 性别:男, 年龄:16

6、结构体中const使用

C++ 结构体中const使用

作为参数,使用const修饰,为防止误操作,修改成员值,如下代码第19行:

void printPerson(constPerson* s)

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

//结构体定义
//人类
struct Person
{
	//姓名
	string name;
	//性别
	string sex;
	//年龄
	int age;
};

//结构体 const使用
void printPerson(const Person* s)
{
	// s->name = "Tracy"; // 加const后,此处不能修改成员的值,为防止误操作
	cout << "结构体地址参数传递:姓名:" << s->name
		<< ", 性别:" << s->sex
		<< ", 年龄:" << s->age << endl;
}

int main()
{
	//结构体 const使用
	Person person = { "Felix", "男", 16 };

	//地址参数传递
	printPerson(&person);

	system("pause");

	return 0;
}

Go语言 结构体中没有const使用方法