每一天都会进行更新，一起冲击未来

StructField和StructType

        StructType---定义数据框的结构

        StructType定义DataFrame的结构，是StructField对象的集合或者列表，通过printSchema可以打印出所谓的表字段名，StructType就是所有字段的集合。在创建dataframe的时候，将StructType作为字段的集合，按照顺序一一给各个字段。

        StructField--定义DataFrame列的元数据

        StructField来定义列名，列类型，可为空的列和元数据。

将StructField和StructType和DataFrame一起使用

        首先创建样例类

case class StructType(fields: Array[StructField])
 case class StructField(
 name: String, 
dataType: DataType, 
nullable: Boolean = true, 
metadata: Metadata = Metadata.empty)

        创建相关的数据以及字段名

//创建数据集合
val simpleData = Seq(
Row("James ","","Smith","36636","M",3000), 
Row("Michael ","Rose","","40288","M",4000), 
Row("Robert ","","Williams","42114","M",4000), 
Row("Maria ","Anne","Jones","39192","F",4000), 
Row("Jen","Mary","Brown","","F",-1) ) 
//创建StructType对象，里面是Array[StructField]类型
val simpleSchema = StructType(Array(
 StructField("firstname",StringType,true), 
StructField("middlename",StringType,true), 
StructField("lastname",StringType,true), 
StructField("id", StringType, true), 
StructField("gender", StringType, true), 
StructField("salary", IntegerType, true) )) 
//创建dataFrame
val df = spark.createDataFrame( 
spark.sparkContext.parallelize(simpleData),simpleSchema)
//打印Schema
 df.printSchema() 

        代码很简答，需要一个数据集合，创建一个StructType对象，里面包含StructField对象。

        前面说过，StructField对象里面包含的是列名以及各种信息。

        创建DataFrame。此时，元数据就是simpleData,所谓的Schema就是simpleSchema。

        看一下各个字段以及“表结构”

        其实上面的案例也比较有一些麻烦，下面来看一下另外一种方法，不用创建样例类

通过StructType.add进行操作

        通过StructType.add进行操作，意味着我们不用再去创建StructField对象，通过add方法，只需要写入字段名称和字段方法就可以完成这个操作。

//创建上下文环境 SparkSql环境
val sparkSQL = new SparkConf().setMaster("local[*]").setAppName("SparkSQL") 
val sparkSession = SparkSession.builder().config(sparkSQL).getOrCreate() 
import sparkSession.implicits._ 
//数据集合 
val simpData = Seq(Row("James", "", "Smith", "36636", "M", 3000), 
Row("Michael", "Rose", "", "40288", "M", 4000),
 Row("Robert", "", "Williams", "42114", "M", 4000), 
Row("Maria", "Anne", "Jones", "39121", "F", 4000), 
Row("Jen", "Mary", "Brown", "", "F", -1))
 //创建StructType对象，将字段进行累加 
val structType = new StructType()
.add("firstname", StringType) 
.add("middlename", StringType) 
.add("lastname", StringType) 
.add("id", StringType) 
.add("gender", StringType) 
.add("salary", StringType)
 //创建DataFrame
 val dataFrame = sparkSession.createDataFrame(
sparkSession.sparkContext.parallelize(simpData), structType) 
dataFrame.printSchema() 
sparkSession.close()

        同样也是需要数据集合以及StructType对象。不过这种操作更加的简便，重要的是不会报错，用最上面的方法创建样例类可能会报错，需要导入不同的包。

使用StructType进行嵌套字段

//创建Spark SQL环境
val sparkSQL = new SparkConf().setMaster("local[*]").setAppName("SparkSQL") 
val sparkSession = SparkSession.builder().config(sparkSQL).getOrCreate() 
import sparkSession.implicits._ 
//创建数据集，其中最里面的Row对象就是嵌套对象
val structData = Seq( Row(Row("James ", "", "Smith"), "36636", "M", 3100),
 Row(Row("Michael ", "Rose", ""), "40288", "M", 4300), 
Row(Row("Robert ", "", "Williams"), "42114", "M", 1400), 
Row(Row("Maria ", "Anne", "Jones"), "39192", "F", 5500),
 Row(Row("Jen", "Mary", "Brown"), "", "F", -1)) 
//通过StructType的add方法进行添加字段
val structType = new StructType()
.add("name",new StructType() 
.add("firstname",StringType) 
.add("middlename",StringType) 
.add("lastname",StringType)) 
.add("id",StringType) 
.add("gender",StringType) 
.add("salary",StringType)
//创建dataframe 
val dataFrame = 
sparkSession.createDataFrame(
sparkSession.sparkContext.parallelize(structData), structType) 
//打印schema
dataFrame.printSchema() 
sparkSession.close()

        因为name字段进行了嵌套，因此在"name"字段后面的类型里面不再是StringType.而是一个嵌套类型 StructType，这个嵌套类型里面再继续进行add。在这里面嵌套了三个字段。

        可以看上面Schema。那么字段的类型是Struct结构。这个Struct结构里面嵌套了三个字段。

        其实上面写错了，纠正一下，最后一个字段应该是IntegerType类型

        如果写StringType类型，虽然打印Schema没有报错，但是进行select的时候就会报错。所以需要进行修改，在这里说明一下。

        dataFrame.select("name").show(false)

        看一下嵌套字段的name

         本来以为Spark SQL的知识只有一点点，没有想到的是Spark SQL里面的知识很多很多，不单单是SQL语言，虽然可以结合Hive或者Mysql写SQL，但是结构化数据使用本身的DSL+SQL更加的简单。

        SQL是重中之重，SQL能解决90%问题，剩下解决不了的问题就交给RDD把        

        在使用分层或者分模块化的项目中，我们可能定义各种各样的O，例如：DO，VO，DTO等等。我们在进行这些对象之间的拷贝时，通过手动写get/set方法进行属性之间的赋值。因为他们之间的属性大部分都是相同的，不仅浪费时间，并且还有大量重复代码。所以，各种框架都添加的对象之间的拷贝的工具类。例如：

1. Spring自带了BeanUtils

2. Apatch自带的BeanUtils

3. Apatch自带的PropertyUtils

4. mapstruct提供Mappers

        本文主要介绍MapStruct的基础知识、Mapstruct的优缺点、Mapctruct的拷贝示例、以及四种方法时间对比。

01

Mapstuct介绍

1.mapstruct的官网地址：   

        https://mapstruct.org

2.mapstruct的文档地址：

        https://mapstruct.org/documentation/stable/reference/html/

3.mapstrcut的示例github地址

        https://github.com/mapstruct/mapstruct-examples

4.mapstruct的介绍

        mapstruct的作用：就像mapstruct官网所说的：mapsrtuct是一个用于简化在JavaBean之间映射的代码生成器工具，并且是基于约定高于配置的方式。

        因为生成的代码使用简单的get/set方法，所以mapstruct可以更快执行、类型之间复制更安全、且容易理解。

02

mapstruct的优缺点

下面看看mapstruct相比其他映射工具有什么优点

1.mapstruct的优点：

• mapstruct是在代码编译的时候，生成其映射规则的代码，所以会在编译时暴露映射错误的代码，让错误提前暴露。

• 因为使用的是一些简单方法：set/get或者Fluent方式，而非反射方式，所以可以更快的执行完成。可以通过04章节查看各个方法效率上对比

• 可以实现深拷贝，上面4种方法中只有mapstruct可以实现深拷贝。但是需要进行配置（使用@mapper(mappingControl=DeepClone.class)进行设置）。其他的都是浅拷贝。从而mapstruct实现修改新对象不会对老对象产生影响。

• 类型更加安全

• 可以进行自定义的映射。可以自定义各种方法，完成属性映射。例如：将两个属性数据合并成一个设置到目标属性上

2.mapstruct的缺点

• 必须添加一个接口或者抽象类，才能实现映射。其他的三种方法都不用写额外接口或者类。

03

Mapstruct的简单示例使用

        上面主要是介绍一下Mapstruct的基础知识，下面看一个mapstruct的简单示例，完成属性之间的映射。

        在示例中，我们使用mapstruct的1.4.2.Final版本，进行试验的

        1.第一个原属性数据

//第一个拷贝对象
public class CompareA {

    private String name;

    private Integer age;

    private LocalDateTime createTime;

    private double score;

    private Double totalScore;

    private Date updateTIme;

    private ChildCompare childCompare;

    private Long days;
    
    //省略其get/set方法，也可使用Lombok,以后讲解lombok与mapstruct结合使用
 }

       2. 第二个目标属性数据

public class CompareB {

    private String name;

    private Integer age;

    private String createTime;

    private double score;

    private Double totalScore;

    private Date updateTIme;

    private ChildCompare childCompare;

    private Long day;
    
    //省略其get/set方法，
}

       3.子类

//这是CompareA和CompareB共有的对象
public class ChildCompare {

    private String childName;

    private long childAge;
    
    //省略其get/set方法，
}

        上面是两个实体对象，观察这两个实体可以看到有两点不同：

• CompareA中有一个createTime属性，数据类型为LocalDateTime，CompareB也有一个createTime，但是属性类型为String
• CompareA有一个days属性，而CompareB有一个day属性

        4.mapstruct接口（这是需要我们手动写的）

package com.moxiao.properties.mapstruct;

import com.moxiao.properties.entity.CompareA;
import com.moxiao.properties.entity.CompareB;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.control.DeepClone;
import org.mapstruct.factory.Mappers;

/**
 * @author moxiao
 */
@Mapper
public interface CompareMapper {

    CompareMapper INSTANCE = Mappers.getMapper(CompareMapper.class);

    @Mapping(target = "day", source = "days")
    @Mapping(target = "createTime", source = "createTime", dateFormat = "yyyy-MM-dd HH:mm:ss")
    @Mapping(target = "childCompare", source = "childCompare", mappingControl = DeepClone.class)
    CompareB mapper(CompareA compareA);
}

        从上面的实现中，我们加入了三个注解：

• 第一个注解：完成属性名不匹配的问题，将compareA中的days（source）赋值到compareB的day（target）
• 第二个注解：完成属性类型不匹配的问题，将compareA中的createTime，赋值到compareB的createTime，这里进行日期的格式转化，使用dateFormat设置格式化类型
• 第三个注解：完成深度拷贝，将compareA中的childCompare属性进行深度拷贝，而不是指针复制，最重要的是最后一个参数：mappingControl = DeepClone.class

        5.最后就会自动生成一个实现类：

package com.moxiao.properties.mapstruct;

import com.moxiao.properties.entity.ChildCompare;
import com.moxiao.properties.entity.CompareA;
import com.moxiao.properties.entity.CompareB;
import java.time.format.DateTimeFormatter;
import javax.annotation.Generated;

@Generated(
    value = "org.mapstruct.ap.MappingProcessor"
)
public class CompareMapperImpl implements CompareMapper {

    @Override
    public CompareB mapper(CompareA compareA) {
        if ( compareA == null ) {
            return null;
        }

        CompareB compareB = new CompareB();

        compareB.setDay( compareA.getDays() );
        if ( compareA.getCreateTime() != null ) {
            compareB.setCreateTime( DateTimeFormatter.ofPattern( "yyyy-MM-dd HH:mm:ss" ).format( compareA.getCreateTime() ) );
        }
        compareB.setChildCompare( childCompareToChildCompare( compareA.getChildCompare() ) );
        compareB.setName( compareA.getName() );
        compareB.setAge( compareA.getAge() );
        compareB.setScore( compareA.getScore() );
        compareB.setTotalScore( compareA.getTotalScore() );
        compareB.setUpdateTIme( compareA.getUpdateTIme() );

        return compareB;
    }

    protected ChildCompare childCompareToChildCompare(ChildCompare childCompare) {
        if ( childCompare == null ) {
            return null;
        }

        ChildCompare childCompare1 = new ChildCompare();

        childCompare1.setChildName( childCompare.getChildName() );
        childCompare1.setChildAge( childCompare.getChildAge() );

        return childCompare1;
    }
}

          从上面的实现，我们可以看出，添加一个childCompareToChildCompare方法，来完成对象之间的深度拷贝。同样的将days设置到了day属性，等等。

          6.最后，我们调用这个mapper方法，就可以完成对象之间的拷贝：如下：

CompareMapper.INSTANCE.mapper(new CompareA());

04

这个对象映射之间的比较

        我们在1,000,000个对象进行各个工具之间的对比，看看效率如何？

package com.moxiao.properties.mapstruct;

import com.moxiao.properties.entity.ChildCompare;
import com.moxiao.properties.entity.CompareA;
import com.moxiao.properties.entity.CompareB;
import org.apache.commons.beanutils.PropertyUtils;
import org.junit.jupiter.api.Test;
import org.springframework.beans.BeanUtils;
import org.springframework.util.StopWatch;

import java.lang.reflect.InvocationTargetException;
import java.time.LocalDateTime;
import java.util.Date;

/**
 * @author moxiao
 */
public class CompareTest {

    int count = 1000000;

    /**
     * Spring中的BeanUtils的使用，最后使用了6700ms
     */
    @Test
    public void springBeanUtils() {
        CompareA populate = populate();
        StopWatch stopWatch = new StopWatch();
        stopWatch.start("开始拷贝");
        for (int i = 0; i < count; i++) {
            CompareB compareB = new CompareB();
            BeanUtils.copyProperties(populate, compareB);
        }
        stopWatch.stop();
        System.out.println(stopWatch.getTotalTimeMillis());
    }

    /**
     * 这是使用mapstruct进行对象拷贝，使用时间54ms
     */
    @Test
    public void mapstructBeanUtils() {
        CompareA populate = populate();
        StopWatch stopWatch = new StopWatch();
        stopWatch.start("开始拷贝");
        for (int i = 0; i < count; i++) {
            CompareB mapper = CompareMapper.INSTANCE.mapper(populate);
        }
        stopWatch.stop();
        System.out.println(stopWatch.getTotalTimeMillis());
    }

    /**
     * 这是Apache的BeanUtils工具，使用7086ms
     * @throws InvocationTargetException
     * @throws IllegalAccessException
     */
    @Test
    public void commonBeanUtils() throws InvocationTargetException, IllegalAccessException {
        CompareA populate = populate();
        StopWatch stopWatch = new StopWatch();
        stopWatch.start("开始拷贝");
        for (int i = 0; i < count; i++) {
            CompareB compareB = new CompareB();
            org.apache.commons.beanutils.BeanUtils.copyProperties(compareB, populate);
        }
        stopWatch.stop();
        System.out.println(stopWatch.getTotalTimeMillis());
    }

    /**
     * 使用Apache中的propertyUtils静态方法，使用3756ms
     * @throws IllegalAccessException
     * @throws NoSuchMethodException
     * @throws InvocationTargetException
     */
    @Test
    public void commonPropertiesUtils() throws IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        CompareA populate = populate();
        StopWatch stopWatch = new StopWatch();
        stopWatch.start("开始拷贝");
        for (int i = 0; i < count; i++) {
            CompareB compareB = new CompareB();
            PropertyUtils.copyProperties(compareB, populate);
        }
        stopWatch.stop();
        System.out.println(stopWatch.getTotalTimeMillis());
    }

    public CompareA populate() {
        CompareA compareA = new CompareA();
        compareA.setAge(10);
        compareA.setName("moxiao");
        compareA.setCreateTime(LocalDateTime.now());
        compareA.setDays(100L);
        compareA.setTotalScore(100.0);
        compareA.setScore(12.3);
        compareA.setUpdateTIme(new Date());
        ChildCompare childCompare = new ChildCompare();
        childCompare.setChildAge(200);
        childCompare.setChildName("moxiaoChild");
        compareA.setChildCompare(childCompare);
        return compareA;
    }

}

        pom文件如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.moxiao</groupId>
    <artifactId>propertiescopytest</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.9</version>
        </dependency>
        
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.3.9</version>
        </dependency>
        
        <dependency>
            <groupId>org.mapstruct</groupId>
            <artifactId>mapstruct</artifactId>
            <version>1.4.2.Final</version>
        </dependency>

        <!-- lombok dependencies should not end up on classpath -->
        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.18</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>commons-beanutils</groupId>
            <artifactId>commons-beanutils</artifactId>
            <version>1.9.4</version>
        </dependency>


    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <annotationProcessorPaths>
                        <path>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok-mapstruct-binding</artifactId>
                            <version>0.2.0</version>
                        </path>
                        <path>
                            <groupId>org.mapstruct</groupId>
                            <artifactId>mapstruct-processor</artifactId>
                            <version>1.4.2.Final</version>
                        </path>
                        <path>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                            <version>1.18.18</version>
                        </path>
                    </annotationProcessorPaths>
                    <showWarnings>true</showWarnings>
                    <compilerArgs>
                        <arg>
                            -Amapstruct.suppressGeneratorTimestamp=true
                        </arg>
                        <arg>
                            -Amapstruct.suppressGeneratorVersionInfoComment=true
                        </arg>
                    </compilerArgs>

                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

上面是各个工具之间的对比，1000000数据之间拷贝的时间为：

综上所述，1百万数据，mapstruct可以在50ms左右完成。

这篇文章只是Mapstruct文章的开头，后续还有：

• 与Lombok结合使用以及注意事项。
• 与SpringBoot进行DI
• 对象之间的深度拷贝，需要最什么配置

更多精彩内容：请关注公众号：

一、概念

结构体(struct)是由一系列具有相同类型或不同类型的数据构成的数据集合，也叫结构。它就将不同类型的数据存放在一起，作为一个整体进行处理。

结构体在函数中的作用不是简便，其最主要的作用就是封装。封装的好处就是可以再次利用。让使用者不必关心这个是什么，只要根据定义使用就可以了。

结构体的大小不是结构体元素单纯相加就行的，因为我们现在主流的计算机使用的都是32Bit字长的CPU，对这类型的CPU取4个字节的数要比取一个字节要高效，也更方便。所以在结构体中每个成员的首地址都是4的整数倍的话，取数据元素时就会相对更高效，这就是内存对齐的由来。每个特定平台上的编译器都有自己的默认“对齐系数”(也叫对齐模数)。程序员可以通过预编译命令#pragmapack(n)，n=1,2,4,8,16来改变这一系数，其中的n就是你要指定的“对齐系数”。

二、规则

1、数据成员对齐规则：结构(struct)(或联合(union))的数据成员，第一个数据成员放在offset为0的地方，以后每个数据成员的对齐按照#pragmapack指定的数值和这个数据成员自身长度中，比较小的那个进行。

2、结构(或联合)的整体对齐规则：在数据成员完成各自对齐之后，结构(或联合)本身也要进行对齐，对齐将按照#pragmapack指定的数值和结构(或联合)最大数据成员长度中，比较小的那个进行。

3、结合1、2可推断：当#pragmapack的n值等于或超过所有数据成员长度的时候，这个n值的大小将不产生任何效果。

三、结构体的定义和使用

语法：struct 结构体名 { 结构体成员列表 }；

• struct 结构体名 变量名
• struct 结构体名 变量名 = { 成员1值 ， 成员2值…}
• 定义结构体时创建变量

#include <stdio.h>
#include <iostream>
#include <string>

using namespace std;
 
//结构体变量创建方式3：定义结构体时顺便创建变量
struct student
{
     //成员列表
     string name;
     int age;
     int score;   
}stu3;
 
 
int main(){
   
    //结构体变量创建方式1： struct 结构体名 变量名
    struct student stu1;
 
    stu1.name = "七喜";
    stu1.age = 20;
    stu1.score = 95;
    cout<<"姓名："<<stu1.name <<" 年龄："<<stu1.age <<" 分数："<<stu1.score <<endl;
 
 
    //创建结构体变量方式2：struct 结构体名 变量名 = { 成员1值 ， 成员2值…}
    struct student stu2 = {"可乐",19,100};
    cout<< "姓名："<< stu2.name <<" 年龄："<<stu2.age<<" 分数："<<stu2.score<< endl;
 
 
    //结构体变量创建方式3：
    stu3.name = "雪碧";
    stu3.age  = 20;
    stu3.score = 90;
    cout<<"姓名："<<stu3.name <<" 年龄："<<stu3.age<<" 分数："<<stu3.score<< endl;
 
    return 0;
}

四、结构体数组

作用：将自定义的结构体放入到数组中方便维护

语法： struct 结构体名 数组名[元素个数] = { { } , { } ,…, { } }

#include <stdio.h>
#include <iostream>
#include <string>

using namespace std;
 
//结构体变量创建方式3：定义结构体时顺便创建变量
struct student
{
     //成员列表
     string name;
     int age;
     int score;   
};

int main(){
   //结构体数组
   struct student stus[3] = {{"康师傅",20,95},{"百事",19,100},{"农夫山泉",20,90}};
   for(int i=0; i < 3; i++){
      cout<<"姓名："<<stus[i].name <<" 年龄："<<stus[i].age<<" 分数："<<stus[i].score<< endl;
   }
 
    return 0;
}

五、结构体指针

. 和-> 区别：

. 来访问结构体成员/属性

-> 来访问其指向的结构体成员/属性

#include <stdio.h>
#include <iostream>
#include <string>

using namespace std;
 
//结构体变量创建方式3：定义结构体时顺便创建变量
struct student
{
     //成员列表
     string name;
     int age;
     int score;   
};
 
 
int main(){
   
    //结构体变量创建方式1： struct 结构体名 变量名
    struct student stu1;
 
    stu1.name = "七喜";
    stu1.age = 20;
    stu1.score = 95;
    cout<<"姓名："<<stu1.name <<" 年龄："<<stu1.age <<" 分数："<<stu1.score <<endl;


   //结构体指针
   struct student *p = &stu1;
   cout<<"姓名："<<(*p).name <<" 年龄："<<(*p).age<<" 分数："<<(*p).score<< endl;
   cout<<"姓名："<< p->name <<" 年龄："<< p->age<<" 分数："<< p->score<< endl;

 
    return 0;
}

六、结构体嵌套

#include <stdio.h>
#include <iostream>
#include <string>

using namespace std;
 
//结构体变量创建方式3：定义结构体时顺便创建变量
struct student
{
     //成员列表
     string name;
     int age;
     int score;   
};


struct teacher
{
    //成员列表
    int id; //职工编号
    string name;  //教师姓名
    int age;   //教师年龄
    struct student stu; //子结构体 学生
};

 
 
int main(){

   //结构体嵌套
   struct teacher t1;
    t1.id = 10000;
    t1.name = "老王";
    t1.age = 40;
 
    t1.stu.name = "张三";
    t1.stu.age = 18;
    t1.stu.score = 100;
 
    cout << " 教师 职工编号： " << t1.id << 
            " 姓名： " << t1.name << 
            " 年龄： " << t1.age << endl;
    
    cout << " 辅导学员 姓名： " << t1.stu.name << 
            " 年龄：" << t1.stu.age << 
            " 考试分数： " << t1.stu.score << endl;


 
    return 0;
}

七、结构体做函数参数

传递方式包括：值传递、地址传递

#include <stdio.h>
#include <iostream>
#include <string>

using namespace std;
 
//结构体变量创建方式3：定义结构体时顺便创建变量
struct student
{
     //成员列表
     string name;
     int age;
     int score;   
};

//值传递
void printStudent1(student stu){
    stu.age = 28;
    cout << "子函数中 姓名：" << stu.name << 
    " 年龄： " << stu.age  << 
    " 分数：" << stu.score << endl;

}


//地址传递
void printStudent2(student *stu)
{
    stu->age = 28;
    cout << "子函数中 姓名：" << stu->name << 
            " 年龄： " << stu->age  << 
            " 分数：" << stu->score << endl;
}

 
 
int main(){
   
    //结构体做函数参数
    struct student stu1;
    stu1.name = "七喜";
    stu1.age = 20;
    stu1.score = 95;
    cout<<"姓名："<<stu1.name <<" 年龄："<<stu1.age <<" 分数："<<stu1.score <<endl

    
    printStudent1(stu1);
    printStudent2(&stu1);

    return 0;
}