首页 > 其他分享 >c语言结构体

c语言结构体

时间：2023-06-01 18:02:50浏览次数：33  
标签：tmp 语言 int age ptr NULL Teacher 结构


定义结构体变量

struct Student{
    char *name;
    int age;
    int score;
};

void main()
{
    struct Student st1;
    system("pause");
}
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
typedef struct Student{
    char *name;
    int age;
    int score;
}student;

void main()
{
    student st1;
    system("pause");
}
struct Student{
    char *name;
    int age;
    int score;
}st2;

void main()
{

    system("pause");
}
struct {
    char *name;
    int age;
    int score;
}st2;

初始化变量

//方法一
typedef struct Teacher
{
    char name[64];
    int age ;
    int id;
}Teacher;
Teacher  t3 = {"aaaa", 31, 01};
//方法二
struct Student2
{
    char name[64];
    int aga ;
}s5 = {"names", 21};
//方法三
struct 
{
    char name[64];
    int aga ;
}s6 = {"names", 21};

访问成员

使用.运算符访问结构体成员
使用->运算符访问结构体成员

在定义了 library 和 library2 两个结构体后，若想要访问其内部成员，应该使用结构体成员运算符点(.)就可以，例如： 

library.value = 9;  
library.title

如何使用结构体指针访问结构体成员
1、结构体指针的定义和初始化

struct book *it;
     it = &library；

2、使用结构体指针it访问结构体成员变量

it->value = 9;
     it->title;

结构体变量作函数参数 VS 结构体指针作函数参数

void  copyTeacher(Teacher to, Teacher from )
{
    to = from;  
}
//值传递
void  copyTeacher02(Teacher *to, Teacher *from )
{
    //(*to) = (*from);
    *to = *from;
}

void main()
{

    Teacher  t1 = {"aaaa", 32, 02};
    Teacher  t2;
    Teacher  t3;
    memset(&t3, 0, sizeof(t3));

    t2 = t1; //=号操作下 编译器的行为

    //编译器给我们提供 简单 =号 赋值操作 。。。我们要顺从
    printf("t2.name:%s \n", t2.name);
    printf("t2.age:%d \n", t2.age);

    copyTeacher(t3, t1);
    printf("copyTeacher() after \n");
    printf("t3.name:%s \n", t3.name);
    printf("t3.age:%d \n", t3.age);
    printf("hello...\n");


    copyTeacher02(&t3, &t1);
    printf("copyTeacher02() after \n");
    printf("t3.name:%s \n", t3.name);
    printf("t3.age:%d \n", t3.age);
    printf("hello...\n");


    system("pause");
    return ;

}
t2.name:aaaa
t2.age:32
copyTeacher() after
t3.name:
t3.age:0
hello...
copyTeacher02() after
t3.name:aaaa
t3.age:32
hello...
请按任意键继续. . .

结构体指针的输入输出模型

#define  _CRT_SECURE_NO_WARNINGS 
#include <stdlib.h>
#include <string.h>
#include <stdio.h>


typedef struct Teacher
{
    char name[64];
    int age ;
    int id;
}Teacher;

void printTeacher(Teacher *array, int num)
{
    int i = 0;

    for (i=0; i<num; i++)
    {
        printf("age:%d \n", array[i].age);
    }
}

void sortTeacer(Teacher *array, int num)
{
    int     i,j;
    Teacher tmp;

    for (i=0; i<num; i++)
    {
        for (j=i+1; j<num; j++)
        {
            if (array[i].age > array[j].age)
            {
                tmp = array[i];  //=号操作  赋值操作
                array[i] = array[j];
                array[j] = tmp;
            }
        }
    }
}


// 结构体数组 3  输入老师的年龄，排序
void main()
{
    int         i = 0;
    Teacher     Array[3];  //在stack 分配内存
    int         num = 3;

    for (i=0; i<num; i++)
    {
        printf("\nplease enter age:");
        scanf("%d", &(Array[i].age) );
    }

    //打印老师年龄
//  for (i=0; i<num; i++)
//  {
//      printf("age:%d \n", Array[i].age);
//  }

    printTeacher(Array, num);

    sortTeacer(Array, num);

    printf("排序之后\n");

    printTeacher(Array, num);

    printf("hello...\n");
    system("pause");
    return ;
}

Teacher * createTeacher(int num)
{
    Teacher * tmp = NULL;
    tmp = (Teacher *)malloc(sizeof(Teacher) * num); //  Teacher     Array[3]
    if (tmp == NULL)
    {
        return NULL;
    }
    return tmp; //

}

void FreeTeacher(Teacher *p)
{
    if (p != NULL)
    {
        free(p);
    }
}

void main233()
{
    int         i = 0;
    //Teacher       Array[3];  //在stack 分配内存
    int         num = 3;
    Teacher *pArray = NULL;
    pArray = createTeacher(num);

    for (i=0; i<num; i++)
    {
        printf("\nplease enter age:");
        scanf("%d", & (pArray[i].age) );
    }

    //打印老师年龄
    //  for (i=0; i<num; i++)
    //  {
    //      printf("age:%d \n", Array[i].age);
    //  }

    printTeacher(pArray, num);

    sortTeacer(pArray, num);

    printf("排序之后\n");

    printTeacher(pArray, num);

    FreeTeacher(pArray);

    printf("hello...\n");
    system("pause");
    return ;
}

高级一点的输出模型

int createTeacher02(Teacher **pT, int num)

就是把简单输出模型的返回值改为int类型，将在堆空间分配的内存从函数参数用二级指针甩出来。

//修改如下
int createTeacher222(Teacher **pT, int num)
{
    Teacher * tmp = NULL;
    tmp = (Teacher *)malloc(sizeof(Teacher) * num); //  Teacher     Array[3]
    if (tmp == NULL)
    {
        return NULL;
    }
    *pT = tmp;
    return 0; //

}
void main()
{
    int         i = 0;
    //Teacher       Array[3];  //在stack 分配内存
    int         num = 3;
    Teacher *pArray = NULL;
    createTeacher222(&pArray,num);

    for (i = 0; i<num; i++)
    {
        printf("\nplease enter age:");
        scanf("%d", &(pArray[i].age));
    }
    printTeacher(pArray, num);

    sortTeacer(pArray, num);

    printf("排序之后\n");

    printTeacher(pArray, num);

    FreeTeacher(pArray);

    printf("hello...\n");
    system("pause");
    return;
}

结构体中套一级指针

#define  _CRT_SECURE_NO_WARNINGS 
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
typedef struct _student{
    char name[64];
    char *alias;
    int age;
}student;

int createStudent(student **ptr,int count)
{
    int ret = 0;

    int i = 0;

    student * tmp = NULL;
    tmp = (student*)malloc(count*sizeof(student));//申请结构体变量所需的内存空间，相当于一个结构体数组
    if (tmp == NULL)//申请失败
    {
        return -1;
    }
    memset(tmp, 0, count*sizeof(student));//初始化新分配到的内存空间

    for (i = 0; i < count;i++){//逐个对结构体变量中的一级指针成员申请空间，否则之前申请的空间只是一个指针变量，这个指针变量并没有实际的内存空间
        tmp[i].alias = (char *)malloc(64);
        if (NULL == tmp[i].alias){
            return -1;
        }
    }
    *ptr = tmp;//通过函数参数甩出内存空间
    return ret;
}

int freeStudent(student **ptr,int count)
{
    int ret = 0;
    int  i = 0;

    student * tmp = NULL;
    if (ptr == NULL){
        return -1;
    }
    tmp = *ptr;
    for (i = 0; i < count; i++)
    {
        if (tmp[i].alias != NULL){
            free(tmp[i].alias);
            tmp[i].alias = NULL;
        }
    }

    free(tmp);

    *ptr = NULL;

    return ret;
}
void printStudent(student *ptr, int count)
{
    int i = 0;
    for (i = 0; i < count; i++){//逐个打印结构体变量的age成员
        printf("age:%d\n", ptr[i].age);
    }
}

//依据年龄排序
void sortStudent(student *ptr, int count)
{
    int i = 0, j = 0;
    student tmp;
    for (i = 0; i < count;i++)
    {
        for (j = i + 1; j < count; j++)
        {
            if (ptr[i].age > ptr[j].age)
            {
                tmp = ptr[i];
                ptr[i] = ptr[j];
                ptr[j] = tmp;
            }
        }
    }
}
int  main()
{
    int ret = 0;
    student *pStudent = NULL;
    int num = 3,i = 0;
    ret = createStudent(&pStudent, num);//创造一个结构体数组
    if (-1 == ret){
        return -1;
    }

    for (i = 0; i < num; i++)//依次输入结构体成员变量的值
    {
        printf("\nplease enter age:");
        scanf("%d", &(pStudent[i].age));

        printf("\nplease enter name:");
        scanf("%s", pStudent[i].name); //向指针所指的内存空间copy数据

        printf("\nplease enter alias:");
        scanf("%s", pStudent[i].alias);  //向指针所指的内存空间copy数据
    }
    printf("排序之前\n");
    printStudent(pStudent, num);

    sortStudent(pStudent, num);

    printf("排序之后\n");
    printStudent(pStudent, num);

    freeStudent(&pStudent,num);
    system("pause");
    return ret;
}

结构体中套二级指针

#define  _CRT_SECURE_NO_WARNINGS 
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

#define FRIEND_NUM 3
typedef struct _student{
    char name[64];
    char *alias;
    char **friends;
    int age;
}student;

int createStudent(student **ptr,int count)
{
    int ret = 0;

    int i = 0, j = 0;

    student * tmp = NULL;
    char **ptmp = NULL;
    tmp = (student*)malloc(count*sizeof(student));//申请结构体变量所需的内存空间，相当于一个结构体数组
    if (tmp == NULL)//申请失败
    {
        return -1;
    }
    memset(tmp, 0, count*sizeof(student));//初始化新分配到的内存空间

    for (i = 0; i < count;i++){//逐个对结构体变量中的一级指针成员申请空间，否则之前申请的空间只是一个指针变量，这个指针变量并没有实际的内存空间
        /*一级指针内存模型*/
        tmp[i].alias = (char *)malloc(64);
        if (NULL == tmp[i].alias){
            return -1;
        }

        /*二级指针第三种内存模型*/
        ptmp = (char**)malloc(FRIEND_NUM*sizeof(char*));//二级指针指向一个二维数组，第一维是char*
        if (ptmp == NULL)
        {
            return -1;
        }
        for (j = 0; j < FRIEND_NUM; j++)
        {
            ptmp[j] = (char*)malloc(64);//第一维的每一个char*指向一个malloc空间
        }
        tmp[i].friends = ptmp;//将二级指针抛出给已分配好的结构体二级指针成员变量

    }
    *ptr = tmp;//通过函数参数甩出内存空间
    return ret;
}

int freeStudent(student **ptr,int count)
{
    int ret = 0;
    int  i = 0,j = 0;
    char ** ptmp = NULL;
    student * tmp = NULL;
    if (ptr == NULL){
        return -1;
    }
    tmp = *ptr;
    for (i = 0; i < count; i++)
    {
        if (tmp[i].alias != NULL){//释放一级指针
            free(tmp[i].alias);
            tmp[i].alias = NULL;
        }

        if (tmp[i].friends != NULL)//释放二级指针
        {
            ptmp = tmp[i].friends;
            for (j = 0; j < FRIEND_NUM; j++)
            {
                if (ptmp[j] != NULL)
                {
                    free(ptmp[j]);
                    ptmp[j] = NULL;
                }
            }
            free(ptmp);
            tmp[i].friends = NULL;//注意ptmp只是一个临时变量，不能修改原结构体成员的值
        }
    }

    free(tmp);

    *ptr = NULL;//修改主调函数的一级指针要使用二级指针

    return ret;
}
void printStudent(student *ptr, int count)
{
    int i = 0;
    for (i = 0; i < count; i++){//逐个打印结构体变量的age成员
        printf("age:%d\n", ptr[i].age);
    }
}

//依据年龄排序
void sortStudent(student *ptr, int count)
{
    int i = 0, j = 0;
    student tmp;
    for (i = 0; i < count;i++)
    {
        for (j = i + 1; j < count; j++)
        {
            if (ptr[i].age > ptr[j].age)
            {
                tmp = ptr[i];
                ptr[i] = ptr[j];
                ptr[j] = tmp;
            }
        }
    }
}
int  main()
{
    int ret = 0;
    student *pStudent = NULL;
    int num = 3,i = 0,j = 0;
    ret = createStudent(&pStudent, num);//创造一个结构体数组
    if (-1 == ret){
        return -1;
    }

    for (i = 0; i < num; i++)//依次输入结构体成员变量的值
    {
        printf("\nplease enter age:");
        scanf("%d", &(pStudent[i].age));

        //printf("\nplease enter name:");
        //scanf("%s", pStudent[i].name); //向指针所指的内存空间copy数据

        //printf("\nplease enter alias:");
        //scanf("%s", pStudent[i].alias);  //向指针所指的内存空间copy数据

        for (j = 0; j < FRIEND_NUM; j++)//给二级指针指向的内存空间的一级指针指向的内存空间赋值
        {
            printf("please enter student name:");
            scanf("%s", pStudent[i].friends[j]);
        }

    }
    printf("排序之前\n");
    printStudent(pStudent, num);

    sortStudent(pStudent, num);

    printf("排序之后\n");
    printStudent(pStudent, num);

    freeStudent(&pStudent,num);
    system("pause");
    return ret;
}

结构体的深浅拷贝

编译器的等号操作只会把指针变量的值拷贝，不会把指针变量指向的内存空间拷贝过去，就是所谓的浅拷贝（只进行简单的值拷贝操作）。
memcpy函数也是浅拷贝
结构体里面出现一级或者二级指针会出现浅拷贝

#define _CRT_SECURE_NO_WARNINGS


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

typedef struct __teacher
{
    char name[64];
    int age;
    char *alias;
}Teacher;

void copyTeacher(Teacher *to,Teacher *from)
{
    //*to = *from;//浅拷贝
    memcpy(to, from, sizeof(Teacher));//浅拷贝
}

int main(void)
{
    Teacher t1;
    Teacher t2;

    strcpy(t1.name,"name1");

    t1.alias = (char*)malloc(100);
    strcpy(t1.alias,"ssss");

    copyTeacher(&t2, &t1);

    if (t1.alias != NULL)
    {
        free(t1.alias);
        t1.alias = NULL;
    }

    if (t2.alias != NULL)//运行到这里由于前面已经free，这里二次free会出错
    {
        free(t2.alias);
        t2.alias = NULL;
    }

    system("PAUSE");
    return 1;
}
//要进行深拷贝只能是显示的分配内存，即在堆里面再开辟一块内存给另一个结构体的指针成员使用，所以可以进行二次释放。主要代码如下：
void copyTeacher(Teacher *to,Teacher *from)
{
    *to = *from;
    to->alias = (char *)malloc(100);
    strcpy(to->alias,from->alias);
    //memcpy(to, from, sizeof(Teacher));
}


标签：tmp,语言,int,age,ptr,NULL,Teacher,结构
From： https://blog.51cto.com/u_16147764/6397246

相关文章

  • C语言链表
    #define_CRT_SECURE_NO_WARNINGS#include<stdlib.h>#include<string.h>#include<stdio.h>/*structTeacher{charname[64];intid;char*p;char**p2;};typedefstructTeacherTeacher;*/typedefstructStudent......
  • 常用的表格检测识别方法——表格结构识别方法 (下）
    常用的表格检测识别方法——表格结构识别方法（下）3.2表格结构识别方法 表格结构识别是表格区域检测之后的任务，其目标是识别出表格的布局结构、层次结构等，将表格视觉信息转换成可重建表格的结构描述信息。这些表格结构描述信息包括：单元格的具体位置、单元格之间的关系、单元格的行......
  • GoWeb项目目录结构参考
    GoWeb项目目录结构目录结构main.gogo.modgo.summodel 数据库操作,增删改查,固化的通用接口view 视图文件controller 通讯请求,API操作等内容等业务逻辑router middleware 中间件部分可以放置在根目录,也可以放置在router内.gin项目一般放置在router目录内confi......
  • Python字典：强大的键值对数据结构
    在Python中，字典是一种多功能和强大的数据结构，它允许我们以键值对的形式存储和操作数据。字典在其他编程语言中也被称为关联数组或哈希映射，它提供了一种高效的方式来根据键检索和更新值。在本文中，我们将探讨Python中的字典概念，并了解如何有效地使用它们。Python中的字典是无序的键......
  • 单元测试及C语言的几个例子
     一、单元测试介绍单元测试是软件开发中的一种测试方式，它主要是对代码中最小可测试单元进行检查和验证。通常来说，单元测试的实施应该在整个软件开发周期的早期就开始，最好是在代码编写过程中就边写边测试，以及在执行集成和系统测试之前启动。下面是单元测试的详解：单元测试的目的：单元......
  • JS垃圾回收——和其他语言一样，JavaScript 的 GC 策略也无法避免一个问题：GC 时，停止响应
    JavaScript内存管理&垃圾回收机制标记清除js中最常用的垃圾回收方式就是标记清除。当变量进入环境时，例如，在函数中声明一个变量，就将这个而变量标记为“进入环境”。从逻辑上讲，永远不能释放进入环境的变量所占用的内存，因为只要执行流进入相应的环境，就可能会用到它们。而当变量离......
  • JS 树型结构 模糊搜索 匹配到所有的节点，包括所有的父节点
    treeData就是el-tree:data要绑定的数据 :data=treeData treeOptions.data是接口返回的原始树形结构数据//根据关键字过滤后的数据consttreeData=computed(()=>{  if(!options.searchText)returntreeOptions.data;  letmhres=filterNodeMethod(opti......
  • TCP/IP 协议体系结构模型
    TCP/IP协议体系结构模型OSI模型通过一系列协议描述了理想的网络通信。TCP/IP并不直接对应于此模型。TCP/IP或者将几个OSI层组合为一个层，或者根本不使用某些层。下表显示了OracleSolaris：实现的TCP/IP层。该表列出了从最顶层（应用层）到最底层（物理网络层）的各层。表 1–2TC......
  • Go数据结构
    Go-数据结构参考整理：1.链表:深入理解container/list&LRU缓存的实现-Mohuishou(lailin.xyz)（提醒：马上要离校，最近在整理本地电脑的笔记，很多东西可能写的有些久，忘记参考链接是否全，若是文章有所问题，请及时评论。）1、链表:深入理解container/list和LRU缓存的实现序Go数据......
  • 青语言开源发布
    青语言发布6月1日，在这个充满欢声笑语的日子里，数心开物工作室开源发布了一门面向青少年、儿童和非专业人士的中文编程语言——青语言。青语言主页：https://qingyuyan.cn青语言文档：https://doc.qingyuyan.cn青语言社区：https://forum.qingyuyan.cn青语言仓库：https://gitee.com/Nj......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99