精华内容
下载资源
问答
  • C#调用C++生成的DLL,并返回结构体引用或者结构体指针多个值,工程已编译好
  • C++结构体指针引用

    2020-06-24 19:17:13
    文章目录类class结构体struct 类 class 定义:可以将变量打包在一起 privacy后面数组或者函数表示都是私有的只能在类里面调用,public表示在类外面和里面都可以公用 结构体 struct 结构体可以构造函数,内部可以写...

    class

    定义:可以将变量打包在一起
    privacy后面数组或者函数表示都是私有的只能在类里面调用,public表示在类外面和里面都可以公用

    结构体

    struct

    结构体可以构造函数,内部可以写参数

    #include <iostream>
    using namespace std;
    struct Person
    {
        int age, height;
        double money;/* Person(){}默认无参数时调用 int main()里面Person p;*/
    
        Person(int _age, int _height, double _money)//可以调用参数,person是构造函数
        {
            age =_age;
            height = _height;
            money =_money;
        }
    };
    
    
    int main()
    {
        Person p(18, 100, 10000);//含参数构造的函数
        return 0;
    }
    

    进程

    有空间的概念,每一个程序长度有映射关系是该空间的数组,打开文件是独立的。
    百度概念:第一,进程是一个实体。每一个进程都有它自己的地址空间,一般情况下,包括文本区域(text region)、数据区域(data region)和堆栈(stack region)。文本区域存储处理器执行的代码;数据区域存储变量和进程执行期间使用的动态分配的内存;堆栈区域存储着活动过程调用的指令和本地变量。第二,进程是一个“执行中的程序”。
    特征
    动态性:进程的实质是程序在多道程序系统中的一次执行过程,进程是动态产生,动态消亡的。
    并发性:任何进程都可以同其他进程一起并发执行
    独立性:进程是一个能独立运行的基本单位,同时也是系统分配资源和调度的独立单位;
    异步性:由于进程间的相互制约,使进程具有执行的间断性,即进程按各自独立的、不可预知的速度向前推进
    结构特征:进程由程序、数据和进程控制块三部分组成。

    可以定义函数变量,局部变量,是自上而下运行。
    百度概念:栈作为一种数据结构,是一种只能在一端进行插入和删除操作的特殊线性表。它按照先进后出的原则存储数据,先进入的数据被压入栈底,最后的数据在栈顶,需要读数据的时候从栈顶开始弹出数据(最后一个数据被第一个读出来)。栈具有记忆作用,对栈的插入与删除操作中,不需要改变栈底指针。
    栈是允许在同一端进行插入和删除操作的特殊线性表。允许进行插入和删除操作的一端称为栈顶(top),另一端为栈底(bottom);栈底固定,而栈顶浮动;栈中元素个数为零时称为空栈。插入一般称为进栈(PUSH),删除则称为退栈(POP)。栈也称为先进后出表。
    栈可以用来在函数调用的时候存储断点,做递归时要用到栈。

    可以定义全局变量,初始化为0;
    百度概念:堆通常是一个可以被看做一棵树的数组对象。堆总是满足下列性质:堆中某个节点的值总是不大于或不小于其父节点的值;堆总是一棵完全二叉树。将根节点最大的堆叫做最大堆或大根堆,根节点最小的堆叫做最小堆或小根堆。常见的堆有二叉堆、斐波那契堆等。
    堆是非线性数据结构,相当于一维数组,有两个直接后继。堆的定义如下:n个元素的序列{k1,k2,ki,…,kn}当且仅当满足下关系时,称之为堆。(ki <= k2i,ki <= k2i+1)或者(ki >= k2i,ki >= k2i+1), (i = 1,2,3,4…n/2)
    若将和此次序列对应的一维数组(即以一维数组作此序列的存储结构)看成是一个完全二叉树,则堆的含义表明,完全二叉树中所有非终端结点的值均不大于(或不小于)其左、右孩子结点的值。由此,若序列{k1,k2,…,kn}是堆,则堆顶元素(或完全二叉树的根)必为序列中n个元素的最小值(或最大值)。

    指针和引用

    指针指向存放变量的值的地址,我们可以通过指针来修改变量的值。
    百度概念:指针也就是内存地址,指针变量是用来存放内存地址的变量,不同类型的指针变量所占用的存储单元长度是相同的,而存放数据的变量因数据的类型不同,所占用的存储空间长度也不同。有了指针以后,不仅可以对数据本身,也可以对存储数据的变量地址进行操作。

    指针的地址与原值的关系是,原值是a(此时a的地址相当于数组下标8位byte,若取得char c 定义c = ‘a’ ,地址输出cout << (void *) &c <<endl;表示存储其下标,即存了97的值用16位字符表示。

    1. 引用必须被初始化,但是不分配存储空间。指针不声明时初始化,在初始化的时候需要分配存储空间。
    2. 引用初始化后不能被改变,指针可以改变所指的对象。
    3. 不存在指向空值的引用,但是存在指向空值的指针。

    定义指针

    实验
    #include <iostream>
     using namespace std;
     
     int main()
     {
         int a = 3;
         int* p = &a;
         
         cout << (void *)p << endl;//a的地址
         cout << *p << endl;//*p = a = 3
         return 0;
     }
         /*
         *p += 5;输出*p表示a的地址增加5个值,但输出a还是原指针地址值
          */
     }int a =1int* p = &a;
    定义*p = 12; cout << *p << endl; //*p变成12
    此时a的值也有所改变为12

    数组指针

    &p = a 表示a的给指针取名字

    #include <iostream>
    using namespace std;
    
    int main()
    {
        int a[5] = {1,2,3,4,5};
        cout << a << endl;//表示输出第一个位置指针地址
        /*for (int i = 0;i<5; i++)
              int* p = &a[i];
              cout << (void*)p << endl;
        */
        for (int i = 0;i<5; i++)
        {
            cout << (void *) &a[i] << endl;//输出a数组5个地址
        }
        return 0;
    }
    
    
    

    链表

    百度定义:链表是一种物理存储单元上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点(链表中每一个元素称为结点)组成,结点可以在运行时动态生成。每个结点包括两个部分:一个是存储数据元素的数据域,另一个是存储下一个结点地址的指针域。

    如果p指针可以用p -> next = p表示存储结点地址而不是它的值;如果p不是指针可以用“.”调用p. next =p;

    链表表示

    Node *p = new Node(1);
    或者 auto q = new Node(1);
    表示返回地址存储1号结点地址;
    auto q =new Node(1)//在二号节点地址
    p -> next = q;//表示p指向构造新的结点q
    一般的存到head里面是第一个结点地址,而不是他的值。

    链表删除

    是指原链表遍布过程中跳过,用next指向下一位;

    删除结点

    head->next = head ->next->next;//表示删除

    添加结点

    auto u = new Node(u);
    u-> next = head;
    head = u;
    //表示在投部添加结点u;

    展开全文
  • 返回结构体引用

    2017-03-23 09:51:00
    以下是类中的一段: 1 volatile Event& pop() volatile 2 { ... 3 return cores[read_pointer++]; // 一个结构体可以整体操作吗? 4 } 5 6 bool is_empty() volatile 7 {...

    以下是类中的一段:

     
      
     1 volatile Event& pop() volatile
     2     {
     3         return cores[read_pointer++];                // 一个结构体可以整体操作吗?
     4     }
     5     
     6     bool is_empty() volatile
     7     {
     8         return read_pointer == write_pointer;
     9     }
    10     
    11     private:
    12     
    13     static const int CAPACITY = 256;
    14     
    15     volatile Event cores[CAPACITY];
    16     volatile alt_u8 read_pointer;
    17     volatile alt_u8 write_pointer;
     
      

     

     
     

    在程序的16行定义了一个结构体数组。

    在程序的第一行volatile Event& pop() volatile中pop是函数名,Event&是返回值的类型。

     

    转载于:https://www.cnblogs.com/zhongguo135/p/6603574.html

    展开全文
  • C++结构体

    2014-03-19 19:47:07
    C/C++语言中的解释 结构体定义  结构体(struct)是由一系列具有相同类型或不同类型的数据构成的数据集合,也叫结构。 结构体作用  结构体和其他类型基础数据类型一样,例如int类型,char类型 只不过结构体可以...

    C/C++语言中的解释

    结构体定义

       结构体(struct)是由一系列具有相同类型或不同类型的数据构成的数据集合,也叫结构

    结构体作用

       结构体和其他类型基础数据类型一样,例如int类型,char类型 只不过结构体可以做成你想要的数据类型。以方便日后的使用。
      在实际项目中,结构体是大量存在的。研发人员常使用结构体来封装一些属性来组成新的类型。
      结构体在函数中的作用不是简便,其最主要的作用就是封装。封装的好处就是可以再次利用。让使用者不必关心这个是什么,只要根据定义使用就可以了。

    结构体的大小与内存对齐

      结构体的大小不是结构体元素单纯相加就行的,因为我们现在主流的计算机使用的都是32Bit字长的CPU,对这类型的CPU取4个字节的数要比取一个字节要高效,也更方便。 所以在结构体中每个成员的首地址都是4的整数倍的话,取数据元素是就会相对更高效,这就是内存对齐的由来。每个特定平台上的编译器都有自己的默认“对齐系数”(也叫对齐模数)。程序员可以通过预编译命令#pragma pack(n),n=1,2,4,8,16来改变这一系数,其中的n就是你要指定的“对齐系数”。
      规则:
      1、数据成员对齐规则:结构(struct)(或联合(union))的数据成员,第一个数据成员放在offset为0的地方,以后每个数据成员的对齐按照#pragma pack指定的数值和这个数据成员自身长度中,比较小的那个进行。
      2、结构(或联合)的整体对齐规则:在数据成员完成各自对齐之后,结构(或联合)本身也要进行对齐,对齐将按照#pragma pack指定的数值和结构(或联合)最大数据成员长度中,比较小的那个进行。
      3、结合1、2颗推断: 当#pragma pack的n值等于或超过所有数据成员长度的时候,这个n值的大小将不产生任何效果

    C++中的结构体

       在C语言中,可以定义结构体类型,将多个相关的变量包装成为一个整体使用。在结构体中的变量,可以是相同、部分相同,或完全不同的数据类型。在C语言中,结构体不能包含 函数 。在 面向对象的程序设计 中,对象具有状态(属性)和行为,状态保存在成员变量中,行为通过成员方法(函数)来实现。 C语言中的结构体只能描述一个对象的状态,不能描述一个对象的行为。在C++中,考虑到C语言到C++语言过渡的连续性,对结构体进行了扩展,C++的结构体可以包含函数,这样,C++的结构体也具有 的功能,与class不同的是,结构体包含的函数默认为public,而不是private。

      

    C++控制台输出例子:

      #include <cstdlib>

      #include <iostream>

    using namespace std;


      //定义结构体
      struct point
      {
      //包含两个变量成员
      int x;
      int y;
      }; 

      int main(int argc, char *argv[])
      {
      struct point pt;
      pt.x=1;
      pt.y=2;
      cout<<pt.x<<endl<<pt.y<<endl;
      return EXIT_SUCCESS;
      }
      


    1 概述

      C语言允许用户自己指定这样一种数据结构,它由不同类型的数据组合成一个整体,以便引用,这些组合在一个整体中的数据是互相联系的,这样的数据结构称为结构体,它相当于其它高级语言中记录。

      声明一个结构休类型的一般形式如下:

      struct 结构体名

      {成员列表};

      结构体名,用作结构体类型的标志,它又称 结构体标记,大括号内是该结构体中的各个成员,由它们组成一个结构体,对各成员都应进行类型声明如:

      类型名 成员名;

    也可以把 成员列表称为 域表,第一个成员也称为结构体中的一个域。成员名定名规则写变量名同。

    struct student

    {

      int num;

      char name[20];

      char sex;

      int age;

      float score;

      char addr[30];
    };

    2 定义结构体类型变量的方法

      前面只是指定了一个结构体类型,它相当于一个模型,但其中并无具体数据,系统对之也不分配实际内存单元,为了能在程序中使用结构类型的数据,应当定义结构体类型的变量,并在其中存放具体的数据,可以采取以下3种方法定义结构体类型变量。

      (1)先声明结构体类型再定义变量名

      如上面已定义了一个结构体类型 struct student,可以用它来定义变量。如:

      struct student  //结构体类型名

      student1, student2//结构体变量名

      定义了 student1, student2 为 struct student 类型的变量。

      在定义了结构体变量后,系统会为之分配内存单元。例如 student1 和 student2在内存中各占59个字节。

      应当注意,将一个变量定义为标准类型(基本数据类型)与定义为结构体类型不同之处在于后者不仅要求指定变量为结构体类型,而且要求指定为某一特定的结构体类型(例如 struct student 类型),因为可以定义出许多种具体的结构体类型。而在定义变量为整形时,只需指定为 int 型即可。

      (2)在声明类型的同时定义变量

    例如:

    struct student

    {

      int num;

      char name[20];

      char sex;

      int age;

      float score;

      char addr[30];
    }student1, student2;

      它的作用与第一种方法相同,即定义了两个 struct student 类型的变量 student1, student2 这种形式的定义的一般形式为

      struct 结构体名

      {

        成员表列

      }变量名表列;

      (3)直接定义结构类型变量

      其一般形式为

      struct

      {

        成员表列

      }变量名表列;

      即不出现结构体名。

    关于结构体类型,有几点要说明:

      a. 类型与变量是不同的概念,不是混同,只能对变量赋值,存取或运算,而不能对一个类型赋值,存取或运算。在编译时,对类型是不分配空间的,只对变量分配空间。

      b. 对结构体中的成员(即 域)可以单元使用,它的作用与地位相当于普通变量,

      c. 成员也可以是一个结构体变量。

    如:

      struct date // 声明一个结构体类型

      {

        int month;

        int day;

        int year;

      }

      struct student

      {

        int num;

        char name[20];

        char sex;

        int age;

        struct date birthday;

        char addr[30];

      }student1, student2;

    先声明一个 struct date 类型,它代表 日期 包括3个成员 month, day, year。然后在声明 struct student 类型时,将成员 birthday 指定为 struct date 类型。

      d. 成员名可以与程序中的变量名相同,二者不代表同一对象

    3 结构体变量的引用

      (1)不能将一个结构体变量作为一个整体进行输入和输出

    只能对结构体变量中的各个成员分别进行输入输出。引用结构体变量中的成员的方式为

      结构体变量名.成员名

    例如 student1.num 表示 student1 变量中的 num 成员,即 student1 的 num 项,可以对变量的成员赋值。例如:

      student1.num = 10010;

    "." 是成员(分量)运算符,它在所有的运算符中优先级最高,因此可以把 student1.num 作为一个整体来看待。上面的赋值语句作用是将整数 10010赋给 student1 变量中的成员 num。

      (2)如果成员本身又属一个结构体类型,则要用若干个成员运算符,一级一级地找到最低一级的成员。只能对最低的成员进行赋值或存取以及运算

    例如:结构体变量 student1 可以这样访问各成员:

    student1.num

    student1.birthday.month

    注意,不能用 student1.birthday 来访问 student1 变量中的成员 birthday,因为 birthday 本身是一个结构体变量。

      (3)对结构体变量的成员可以像普通变量一样进行各种运算(根据其类型决定可以进行的运算)

    student2.score = student1.score;

    sum = student1.score + student2.score;

    student1.age ++;

    ++ student1.age;

    由于 "." 运算符的优先级最高,因此 student1.age ++ 是对 student1.age 进行自加运算。而不是先对 age 进行自加运算。

      (4)可以引用结构体变量成员的地址。也可以引用结构体变量的地址。如:

      scanf("%d", &student1.num);// 输入 student1.num 的值

      printf("%o", &student1);// 输出 student1 的首地址

    但不能用以下语句整体读入结构体变量如:

      scanf("%d,%s,%c,%d,%f,%s", &student1);

    结构体变量的地址主要用于作函数参数,传递结构体的地址。

    4 结构体变量的初始化

      和其它类型变量一样,对结构体变量可以在定义时指定初始值。

    如:

    #include <stdio.h>

    struct student

    {

      long int num;

      char name[20];

      char sex;

      char addr[30];
    }a = {89031, "Li Lin", 'M', "123 Beijing Road"};

    void main()
    {

      printf("NO. : %d\nname: %s\nsex: %c\naddress: %s\n", a.num, a.name, a.sex, a.addr);
    }

    5 结构体数组

      一个结构体变量中可以存放一组数据(如一个学生的学号,姓名,成绩等数据)。如果有10个学生的数据需要参加运算,显然应该用数组,这就是结构体数组。结构体数组与以前介绍过的数据值型数组不同之处在于每个数组元素都一个结构体类型的数据,它们分别包括各个成员(分量)项。

    5.1 定义结构体数组

      和定义结构体变量的方法相仿,只需说明其为数组即可。

      struct student

      {

        int num;

        char name[20];

        char sex;

        int age;

        float score;

        char addr[30];

      };

      struct student stu[3];

      以上定义了一个数组 stu,其元素为 struct student 类型数据,数组有 3 个元素。也可以直接定义一个结构体数组。如:

      struct student

      {

        int num;

        ....

      }stu[3];

      struct

      {

        int num;

        ...

      }stu[3];

    5.2 结构体数组的初始化

      与其它类型数组一样,对结构体数组可以初始化如:

      struct student

      {

        int mum;

        char name[20];

        char sex;

        int age;

        float score;

        char addr[30];

      }stu[3] = {{10101,"Li Lin", 'M', 18, 87.5, "103 Beijing Road"},

            {10101,"Li Lin", 'M', 18, 87.5, "103 Beijing Road"},

            {10101,"Li Lin", 'M', 18, 87.5, "103 Beijing Road"}};

      定义数组 stu 时,元素个数可以不指定,即写成以下形式:

      stu[] = {{...},{...},{...}};

    编译时,系统会根据给出初值的结构体常量的个数来确定数组元素的个数。

      当然,数组的初始化也可以用以下形式:

      struct student

      {

        int num;

        ...

      };

      struct student stu[] = {{...},{...},{...}};

    即先声明结构体类型,然后定义数组为该结构体类型,在定义数组时初始化。

      从以上可以看到,结构体数组初始化的一般形式是在定义数组的后面加上

    5.3 结构体数组应用举例

      下面例子说明结构体数组的定义和引用。

    #include <stdio.h>

    #include <string.h>

    #include <stlib.h>

    struct person

    {

      char name[20];

      int count;

    }leader[3] = {{"Li", 0},

           {"Zhang", 0},

           {"Fun", 0}};

    void main()

    {

      int i, j;

      char leader_name[20];

      for(i = 1; i<= 10;i++)

      {

        scanf("%s", leader_name);

        for(j=0;j<3;j++)

          if(strcmp(leader_name, leader[j].name) == 0)

            leader[j].count ++;

      }

      printf("\n");

      for(i=0;i<3;i++)

        printf("%5s: %d\n", leader[i].name, leader[i].count);

      system("pause");
    }

    运行结果如下:

    LI
    Li
    Fun
    Zhang
    Zhang
    Fun
    Li
    Fun
    Zhang
    Li

       Li: 3
    Zhang: 3
      Fun: 3

    6 指向结构体类型数据的指针

      一个结构体变量的指针就是该变量所占据的内存段的起始地址,可以设一个指针变量,用来指向一个结构体变量,此时该指针变量的值是结构体变量的起始地址。指针变量也可以用来指向结构体数组中的元素。

    6.1 指向结构体变量的指针

      指向结构体变量的指针的应用:

    #include <string.h>

    #include <stdio.h>

    #include <stdlib.b>

    struct student

    {

      long num;

      char name[20];

      char sex;

      float score;
    };

    void main()

    {

      struct student stu_1;

      struct student *p;

      p = &stu_1;

      stu_1.num = 89101;

      strcpy(stu_1.name, "Li Lin");

      stu_1.sex = 'M';

      stu_1.score = 89.5;

      printf("NO. :%ld\nname: %s\nsex:%c\nscore:%f\n", stu_1.num, stu_1.name, stu_1.sex, stu_1.score);

      printf("NO. :%ld\nname: %s\nsex:%c\nscore:%f\n", (*p).num, (*p).name, (*p).sex, (*p).score);

      system("pause");
    }

      在主函数中声明了 struct student 类型,然后定义了一个 struct student 类型的变量,stu_1 同时又定义一个指针变量 p ,它指向一个 struct student 类型的数据,在函数的执行部分将结构体变量 stu_1 的起始地址赋给指针变量 p ,也就是使 p 指向 stu_1 然后对 stu_1 的各成员赋值,第二个 printf 函数也是用来输出 stu_1 各成员的值,但使用的是 (*p).num 这样的形式, (*p) 表示 p 指向的结构体变量,(*p).num 是 p 指向的结构体变量中的成员 num 。注意 *p 两侧的括弧不可省略,因为成员运算符 '.' 优先于 '*' 运算符,*p.num 就等价于 *(p.num)

    运行结果如下:

    NO. :89101
    name: Li Lin
    sex:M
    score:89.500000
    NO. :89101
    name: Li Lin
    sex:M
    score:89.500000

      可以看到两个 printf 输出的结果相同。

      在C语言中,为了使用方便和使之直观,可以把 (*p).num 改用 p->num 来代替,它表示 *p 所指向的结构体变量中的 num 成员,同样,(*p).name 等价于 p->name

    也就是说以下三种形式等价:

      a. 结构体变量.成员名

      b. (*p).成员名

      c. p->成员名

      上面的最后一个 printf 函数输了项可以改写为

      printf("NO. :%ld\nname: %s\nsex:%c\nscore:%f\n",p->num, p->name, p->sex, p->score);

      其中 -> 称为指向运算符。

      分析以下几种运算符

      p -> n 得到 p 指向的结构体变量中的成员 n 的值

      p -> n ++ 得到 p 指向的结构体变量中的成员 n 的值,用完值后使它加1

      ++p -> n 得到 p 指向的结构体变量中的成员 n 的值使之加 1 (先加)

    6.2 指向结构体数组的指针

      以前介绍过可以使用指向数组或数组元素的指针和指针变量,同样,对结构体数组及其元素也可以用指针变量来指向。

      指向结构体数组的指针的应用

    #include <stdio.h>

    #inlcude <stdlib.h>

    struct student

    {

      int num;

      char name[20];

      char sex;

      int age;

    };

    struct student stu[3] = {{10101, "Li Lin", 'M', 18},

                 {10102, "Zhang Fun", 'M', 19},

                 {10103, "Wang Min", 'F', 20}};

    void main()

    {

      struct student *p;

      printf("No.  name    sex    age\n");

      for(p=stu; p<stu+3;p++)

        printf("%5d %-20s %2c %4d\n", p->num, p->name, p->sex, p->age);

      system("pause");
    }

    运行结果如下:

    No.  name    sex    age
    10101 Li Lin                M     18
    10102 Zhang Fun        M     19
    10103 Wang Min          F      20

    注意以下两点:

    (1)如果 p 的初值为 stu,即指向第一个元素,则 p + 1 后指向下一个元素的起始地址。例如:

      (++p) -> num 先使 p 自加 1 ,然后得到它指向的元素中的 num 成员的值(即10102)。

      (p++) ->num 先得到 p->num 的值(即10101),然后使 p 自加 1 ,指向 stu[1]。

      注意以上二者的不同。

      (2)程序已定义了指针 p 为指向 struct student 类型数据的变量,它只能指向一个 struct student 型的数据(p 的值是 stu 数组的一个元素的起始地址),而不能指向 stu 数组元素中的某一成员,(即 p 的地址不能是成员地址)。例如,下面是不对的:

      p = &stu[1].name

    编译时将出错。千万不要认为反正 p 是存放地址的,可以将任何地址赋给它。如果地址类型不相同,可以用强制类型转换。例如:

      p = (struct student *)&stu[1].name;

    此时,在 p 中存放 stu[1] 元素的 name 成员的起始地址。

    6.3 用结构体变量和指向结构体的指针作函数参数

      将一个结构体变量的值传递给另一个函数,有3个方法:

      (1)用结构体变量的成员作参数,例如:用 stu[1].num 或 stu[2].name 作函数实参,将实参值传给形参。用法和用普通变量作实参是一样的,属于 值传递 方式。应当注意实参与形参的类型保持一致。

      (2)用结构体变量作参数。老版本的C系统不允许用结构体变量作实参,ANSI C取消了这一限制。但是用结构体变量作实参时,采取的是 值传递 的方式,将结构体变量所占的内存单元全部顺序传递给形参。大时,开销是形参也必须是同类型的结构体变量。在函数调用期间形参也要占用内存单元。这种传递方式在空间和时间上开销较大,如果结构体的规模很很可观的,此外由于采用值传递方式,如果在执行被调用函数期间改变了形参(也是结构体变量)的值,该值不能返回主调函数,这往往造成使用上的不便。因此一般较少用这种方法。

      (3)用指向结构体变量(或数组)的指针作实参,将结构体变量(或数组)的地址传给形参。

    用结构体变量作函数参数。

    #include <stdio.h>

    #define FORMAT "%d\n%s\n%f\n%f\n%f\n"

    struct student

    {

      int num;

      char name[20];

      float score[3];

    };

    void print(struct student stu)

    {

      printf(FORMAT, stu.num, stu.score[0], stu.score[1], stu.score[2]);

      printf("\n");
    }

    void main()

    {

      struct student stu;

      stu.num = 12345;

      strcpy(stu.name, "Li Li");

      stu.score[0] = 67.5;

      stu.score[1] = 89;

      stu.score[2] = 78.6;

      printf(stu);
    }

    将上面改用指向结构体变量的指针作实参。

    #include <stdio.h>

    #define FORMAT "%d\n%s\n%f\n%f\n%f\n"

    struct student

    {

      int num;

      char name[20];

      float score[3];

    }stu = {12345, "Li Li", 67.5, 89, 78.6};

    void print(struct student *p)

    {

      printf(FORMAT, p->num, p->name, p->score[0], p->score[1], p->score[2]);

      printf("\n");
    }

    void main()

    {

      print(&stu);
    }

    7 用指针处理链表

    7.1 链表概述

      链表是一种常见的重要的数据结构。它是动态地进行存储分配的一种结构。

      链表有一个 头指针 变量,它存放一个地址,该地址指向一个元素,链表中每一个元素称为 结点,每个结点都应包括两个部分,一为用户需要用的实际数据,二为下一个结点的地址。可以看出,头指针 head 指向第一个元素,第一个元素又指向第二个元素,。。。。直到最后一个元素,该元素不再指向其他元素,它称为 表尾,它的地址部分放一个 NULL(表示 空地址)链表到此结束。

      可以看到链表中各元素在内存中可以不是连续存放的,要找某一元素,必须先找到上一个元素,根据它提供的下一元素地址才能找到下一个元素。如果不提供 头指针 head 则整个链表无法访问。

      可以看到。这种链表的数据结构,必须利用指针变量才能实现,即一个结点中应包含一个指针变量,用它存放下一结点的地址

      前面介绍了结构体变量,用它作链表中的结点是最合适的,一个结构体变量包含若干成员,这些成员可以是数值类型,字符类型,数组类型,也可以是指针类型,我们用这个指针类型成员来存放下一个结点的地址。例如可以设计这样一个结构体类型:

      struct student

      {

        int num;

        float score;

        struct student *next;

      };

      其中成员 num 和 score 用来存放结点中的有用数据(用户需要用到的数据),next 是指针类型成员,它指向 struct student 类型数据(这是 next 所在结构体类型)。一个指针类型的成员既可以指向其他类型的结构体数据,也可以指向自己所在的结构体类型的数据。现在 next 是 struct student 类型中的一个成员,它又指向 struct student 类型的数据。用这种方法就可以建立链表。

      请注意:只是定义一个 struct student 类型,并未实际分配存储空间,只有定义了变量才分配内存单元

    7.2 简单链表

      下面通过一个例子来说明如何建立和输出一个简单链表

    #include <stdio.h>

    #include <stdlib.h>

    #define NULL 0

    struct student

    {

      long num;

      float score;

      struct student *next;
    };

    void main()

    {

      struct student a, b, c, *head, *p;

      a.num = 99101; a.score = 89.5;

      b.num = 99103; b.score = 90;

      c.num = 99107; c.score = 85;//对结点的 num 和 score 成员赋值

      head = &a;//将结点 a 的起始地址赋给头指针 head

      a.next = &b;//将结点 b 的起始地址赋给 a 结点的 next 成员

      b.next = &c;

      c.next = NULL;// c 结点的 next 成员不存放其他结点地址

      p = head;//使 p 指针指向 a 结点

      do

      {

        printf("%ld %5.1f\n", p->num, p->score);// 输出 p 指向的结点的数据

        p = p->next;//使 p 指向下一结点

      }while(p != NULL);//输出完 c 结点后 p 的值为 NULL

      system("pause");
    }

    运行结果

    99101  89.5
    99103  90.0
    99107  85.0

    7.3 处理动态链表所需的函数

      (1)malloc 函数

      void *malloc(unsigned int size);

      作用是在内存的动态存储区中分配一个长度为 size 的连接空间。些函数的值(即返回值)是一个指向分配空间起始地址的指针(基类型为 void)。如果些函数未能成功地执行(例如内存空间不足)则返回空指针 NULL。

      (2)calloc 函数

      void *calloc(unsigned n, unsigned size);

      其作用是在内存的动态区存储中分配 n 个长度为 size 的连续空间。函数返回一个指向分配空间起始地址的指针,如果分配不成功,返回 NULL。

      用 calloc 函数可以为一维数组开辟动态存储空间, n 为数组元素个数,每个元素长度为 size。  

      (3)free 函数

      void free(void *p);

      其作用是释放由 p 指向的内存区,使这部分内存区能被其它变量使用, p 是最后一次调用 calloc 或 malloc 函数时返回的值。free 函数无返回值。

      请注意:以前的C版本提供的 malloc 和 calloc 函数得到的是指向字符型数据的指针。ANSI C 提供的 malloc 和 calloc 函数规定为 void * 类型。

    7.4 建立动态链表

      所谓建立动态链表是指在程序执行过程中从无到有地建立起一个键表,即一个一个地开辟结点和输入各结点数据,并建立起前后相链的关系。

      

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

    #define NULL 0
    #define LEN sizeof(struct student)

    struct student
    {
      long num;
      float score;
      struct student *next;
    };

    struct student *create()
    {
      struct student *p1, *p2, *head;
      int num;
      float score;
      int n = 0;

      head = NULL;

      p1 = p2 = (struct student *)malloc(LEN);

      printf("please input num and score.\n");
      scanf("%d,%f", &p1->num, &p1->score);

      while(p1->num != 0)
      {

        n ++;

        if(n == 1)

          head = p1;

        else

          p2->next = p1;

        p2 = p1;
        p1 = (struct student *)malloc(sizeof(struct student));

        printf("please input num and score.\n");

        scanf("%d,%f", &p1->num, &p1->score);
      }
      p2->next = NULL;
      return head;
    }

    void printlist(struct student *head)
    {
      struct student *p;
      p = head;

      if(head != NULL)

      {

        do

        {

          printf("num=%d score=%f\n", p->num, p->score);
          p = p->next;

        }while(p != NULL);

      }

    }

    void main()
    {
      struct student *head;
      head = create();
      printlist(head);
      system("pause");
    }

    以下是对链表的各种操作

    打印链表

    void printlist(struct student *head)
    {
     struct student *p;
     p = head;

     if(head != NULL)
     {
      do
      {
       printf("num=%d score=%5.2f\n", p->num, p->score);
       p = p->next;
      } while (p != NULL);
     }
    /* while(p -> next != NULL)
     {
      printf("num=%d score=%f\n", p->num, p->score);
      p = p->next;
     }*/
    }

    删除节点

    struct student *delNode(struct student *head, int num)
    {
     printf("delNode.\n");
     struct student *p1, *p2;
     if(head == NULL)
     {
      printf("The List is NULL.\n");
     }
     else
     {
      p1 = head;
      while(p1->next != NULL && p1->num != num)
      {
       p2 = p1;
       p1 = p1->next;
      }
      if(p1->num == num)
      {
       if(p1 == head)
        head = p1->next;
       else
        p2->next = p1->next;
      }
      else
       printf("Can not find list num.\n");
     }
     return head;
    }

    更新节点

    struct student *update(struct student *head, int index, int num, float score)
    {
     printf("update.\n");
     struct student *p;
     if(head == NULL)
     {
      printf("The List is NULL.\n");
     }
     else
     {
      p = head;
      while(p->next != NULL && p->num != index)
      {
       p = p->next;
      }
      if(p->num == index)
      {
       p->num = num;
       p->score = score;
      }
      else
       printf("Can not find list index.\n");
     }
     return head;
    }

    增加节点

    struct student *add(struct student *head, int index, int num, float score)
    {
     printf("add.\n");
     struct student *p1, *p2, *p3;
     if(head == NULL)
     {
      printf("The List is NULL.\n");
     }
     else
     {
      p1 = p2 = head;
      while(p1->next != NULL && p1->num != index)
      {
       p1 = p1->next;
       p2 = p1;
      }
      if(p1->num == index)
      {
       p3 = (struct student *)malloc(LEN);
       p3->num = num;
       p3->score = score;

       if(p2->next == NULL)
       {
        p2->next = p3;
        p3->next = NULL;
       }
       else
       {
        p3->next = p2->next;
        p2->next = p3;   
       }
      }
      else
       printf("Can not find list index.\n");
     }
     return head;
    }

      


    展开全文
  • C++之结构体结构体定义-day28-4初始化的三种形式-day28-6结构体引用和深浅拷贝-day28-11头文件作用和结构体声明-day28-12结构体赋值原理-day28-13结构体嵌套实现继承-day28-14结构体数组-day29-1结构体动态数组...

    结构体

    定义-day28-4

    需要注意只有在初始化的时候,才可以使用大括号进行赋值运算,如果已经给定义了变量,不可以再使用大括号{}进行初始化。

    struct dangdang  ddd[10][10];//每个数组是一个结构体
    struct a1
    {
    	char email[20];
    	char name[10];
    	long long phone;
    	double lelvel;
    
    };
    
    struct 
    {
    	char email[20];
    	char name[10];
    	long long phone;
    	double lelvel;
    
    }qxg;//匿名结构体,锁定变量的数量
    //结构体中嵌套结构体实现继承
    void main()
    {
    	struct a1 qxl;
    	strcpy(qxl.email, "1183129553@qq.com");
    	strcpy(qxl.name, "qxl");
    	qxl.phone = 18810619072;
    
    	struct a1 *p;
    	p = &qxl;
    	printf("%s\n%s\n%lld\n", qxl.email, qxl.name, qxl.phone);
    	printf("%s\n%s\n%lld\n", p->email, p->name, p->phone);
    	system("pause");
    
    }
    
    
    1. 结构体类型仅仅作用于本文件,如果跨文件使用需要复制过去,因此应放置在h文件中,而不应该放置在源文件中,在工程文件中,一般是按照这种形式组织结构体头文件。
    2. 结构体定义,重名的情况下内层覆盖外层

    初始化的三种形式-day28-6

    struct dangdang1
    {
    	char name[10];
    	char email[30];
    	long long phone;
    }d2 = { "qxl","1183129553@qq.com",18810619072 };//初始化
    struct dangdang
    {
    	char name[10];
    	char email[30];
    	long long phone;
    }d3 = { .name="qxl",.email="1183129553@qq.com",.phone=18810619072 };//选择性初始化
    struct 
    {
    	char name[10];
    	char email[30];
    	long long phone;
    }d1 = { .name = "qxl",.email = "1183129553@qq.com",.phone = 18810619072 };//匿名结构体
    

    结构体引用和深浅拷贝-day28-11

    结构体变量不能整体引用(打印),只能引用变量成员(逐一打印),因为结构体中并不限定数据类型,而引用(打印)成员是需要知道其数据类型的。
    只有在初始化的时候才能使用大括号进行赋值。
    结构体之间没有比较运算符,只能对成员变量进行运算

    void main()
    {
    	struct str mystr1;
    	mystr1.p = malloc(30);
    	mystr1.num = 10;
    	strcpy(mystr1.p, "hello world");
    	struct str mystr2 = mystr1;//拷贝,指向同一内容
    	//struct str mystr2;
    	mystr2.p = malloc(30);
    	strcpy(mystr2.p, mystr1.p);//深拷贝
    	free(mystr1.p);
    	printf("%s\n%d\n%s\n%d", mystr1.p, mystr1.num, mystr2.p, mystr2.num);
    	system("pause");
    }
    

    对于指针都会有这个问题

    头文件作用和结构体声明-day28-12

    头文件的作用是放置变量、函数、结构体声明;为什么只放声明呢,是否可以将定义也包含呢?当然不可以。因为在一个工程中可能有多个c文件会include头文件,如果h文件中包含了定义,多次include导致重定义问题。

    结构体赋值原理-day28-13

    结构体是内存拷贝,结构体当中只有指针是浅拷贝,其他(数组等,拷贝的时候占据的 字节空间是定了的)是副本机制,深拷贝。
    结构体拷贝的实现机制是memcpy

    struct mystruct
    {
    	int a[5];
    	char str[10];
    	char *p;
    };
    void main()
    {
    	//memcpy是内存copy
    	struct mystruct my1 = { {1,2,3,4,5},"calc",NULL };
    	my1.p = malloc(30);
    	strcpy(my1.p, "20200112");
    
    	struct mystruct my2 = my1;
    	my1.a[3] = 111;
    	my1.str[2] = 'X';
    	*(my1.p) = 'X';
    
    	for (int i = 0; i < 5; i++)
    	{
    		printf("%d,%d\n", my1.a[i], my2.a[i]);
    	}
    	printf("%s, %s\n", my1.str, my2.str);
    	printf("%s, %s\n", my1.p, my2.p);
    	system("pause");
    }
    //输出
    1,1
    2,2
    3,3
    111,4
    5,5
    caXc, calc
    X0200112, X0200112
    

    结构体嵌套实现继承-day28-14

    #include<stdlib.h>
    #include<stdio.h>
    
    struct life
    {
    	int canmove;
    };
    struct animal
    {
    	struct life life1;
    	int canrun;
    };
    struct man
    {
    	struct animal animal1;
    	int canthink;
    };
    struct triger
    {
    	struct animal animal1;
    	int tooth;
    	int ismao;
    };
    //预习链表,使用链表解决内存不连续的问题
    struct listnode
    {
    	int num;
    	struct listnode *pleftlist;
    	struct listnode *prightlist;
    };
    struct file
    {
    	int size;
    	int isbin;
    	int isexe;
    	int time;
    };
    struct filesnode
    {
    	struct file *pfile;//多个文件
    	int pfiles;//指针数组
    	struct filesnode *pfielsnode;//多个文件夹
    	int ppfiles;
    };
    struct array//数组实现
    {
    	int *p;
    	int length;
    }
    //链表嵌套可以实现继承,可以描述事物的复杂属性,c语言数组结构都是结构体
    

    结构体数组-day29-1

    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    struct //匿名结构体
    {
    	int num;//c要求一个结构或者联合至少有一个成员变量
    	double db;
    }*p,x[10],z;//定义结构体指针数组变量
    //匿名结构体如果有指针,指针可以开辟内存,所以无法锁定数量
    struct Mystruct
    {
    	int data;
    	int id;
    }my[10];//第二种定义
    struct csdn
    {
    	char name[100];
    	char pass[100];
    	char email[100];
    }csdndata[3] = 
    {
    	{"qxl","111","1576@163.com"},
    	{ "lh","222","1577@163.com" },
    	{ "lrr","333","1578@163.com" }
    }, *csdnp;
    void main()
    {
    	//struct Mystruct my[10];//第一种定义
    	//struct Mystruct *p = (struct Mystruct[10]) { 0 };//栈区,数组
    	//struct Mystruct my[2] = { {10,20},{10,20} };//结构体数组初始的一般形式
    	//struct Mystruct *p = (struct Mystruct[2]) { 10, 20, 10, 20 };//一定要遵循顺序
    	//以上两种数组都属于是栈上的数组
    	struct Mystruct my[] = { {0},{0} };//初始化为空,设定为0
    	csdnp = (struct csdn[]) {//指针赋值之后如何调用
    		{"qxl", "111", "1576@163.com"},
    		{ "lh","222","1577@163.com" },
    		{ "lrr","333","1578@163.com" }
    	};
    	for (int i = 0; i < sizeof(csdndata) / sizeof(csdndata[0]); i++)
    	{
    		//a.b   &a->b  p->b   (*p).b
    		//char *p = strstr(csdndata[i].email, "1578@163.com");
    		//char *p = strstr(csdnp[i].email, "1578@163.com");//[]表示是变量了
    		//char *p = strstr((csdnp+i)->email, "1578@163.com");//(csdnp+i)还是地址的形式
    		char *p = strstr((*(csdnp + i)).email, "1578@163.com");//(csdnp+i)还是地址的形式
    		//printf("%d\n", csdndata[i].email);
    		if (p != NULL)
    		{
    			puts(csdndata[i].pass);
    		}
    	
    	}
    	
    	system("pause");
    }
    

    结构体动态数组

    #define _CRT_SECURE_NO_WARNINGS
    #include<stdlib.h>
    #include<stdio.h>
    #include<string.h>
    #include<malloc.h>
    
    struct csdn
    {
    	int num;
    	int id;
    };
    void main1()
    {
    	int num;
    	scanf("%d", &num);
    	struct csdn *csdn1 = malloc(sizeof(struct csdn)*num);//堆
    	struct csdn *csdn2 = alloca(sizeof(struct csdn)*num);//栈
    	//以上不会全都初始化?使用memset进行初始化
    	memset(csdn1, 0, sizeof(struct csdn)*num);
    	memset(csdn2, 0, sizeof(struct csdn)*num);
    	for (int i = 0; i < num; i++)
    	{
    		printf("%d,%d,%d,%d\n", csdn1[i].num, csdn1[i].id, csdn2[i].num, csdn2[i].id);
    	}
    	system("pause");
    }
    void main()
    {
    	struct csdn *p2 = (struct csdn[]) {1,2,3,4};//指向数组
    	printf("\n%d",p2[1].id);
    	printf("\n%d",(&p2[1])->id);
    	printf("\n%d", (p2+1)->id);
    	printf("\n%d",(*(p2+1)).id);
    	
    	system("pause");
    }
    

    结构体大小

    1. 结构体大小等于所有成员的大小之和
    2. Char int float double是基本类型 double是最宽基本成员,数组和结构体不是最宽基本成员
    3. 设定于当前最宽 ,二者取最短的为最宽
    4. 结构体成元的地址-结构体的首地址=偏移量,必须是当前成员的整数倍
    5. 结构体尾部不足的部分,就会被填充
    6. 结构体对齐,注意节省内存
    7. 在实际工作中使用较少,在架构设计中考虑较多。
    8. 以上是默认的对齐方式,通过设置修改对齐方式
    	char num2;	
    	char num3;
    	int num1;//占据8个字节
    
    	char num2;
    	int num1;
    	char num3;//占据12个字节
    

    指针和结构体

    1. 结构体有副本机制,如果结构体中有数组,对数组也生效。
    2. 结构体返回值也有副本机制
    3. 函数返回数组C语言不支持
    4. 内存分配及赋值
    5. 结构体存储以8字节为最小单位,如果不足8,补位
    #include<stdio.h>
    struct
    {
    	char num1;
    	double num2;
    	int num3;
    	char ch1;
    	char ch2;//int char char 累加为8个字节
    	long long num4;
    }s1;//存储以8字节为最小单位,如果不足8,补位,所以占用的size为32;
    void main()
    {
    	printf("%d", sizeof(s1));//输出32
    
    	getchar();
    }
    
    
    
    struct data
    {
    	int num;
    };
    void main3()
    {
    	//struct data *pnew = malloc(sizeof(struct data) * 10);
    	struct data *pnew = alloca(sizeof(struct data) * 10);//分配在栈,不需要手动free释放内存
    	int i = 0;
    	for (struct data *p = pnew; p < pnew + 10; p++)
    	{
    		printf("%p, %d\n",p,((*p).num) = i++);
    	}
    	system("pause");
    }
    

    函数跨数据传递数-day44-3

    Return数据变量为什么合法?因为是副本机制,局部函数中的变量已经释放。
    动态分配内存(malloc)能否跨函数使用?动态分配内存是在堆区完成的,返回指针后不会释放内存。但函数返回时,栈区的内容会被释放,因此不能返回指向栈区的指针。
    是否可以返回只读存储区的指针?
    Char *p = “hello”;
    Return p;//返回局部指针是ok的,只能用于输出,不能用于输入。

    Typedef结构体和共用体

    #include<stdio.h>
    #include<stdlib.h>
    
    struct Mystruct
    {
    	int num;
    	double score;
    };
    union Myunion
    {
    	int num;
    	double score;
    };
    typedef struct Mystruct m1;
    typedef union Myunion u1;
    
    void main1()
    {
    	m1 mm1 = { mm1.num = 1, 1.0 };
    	u1 uu1 = { 1 };
    }
    

    共用体

    共用体变量任何时刻只有一个变量存在

    初始化

    共用体只能对一个变量初始化

    起别名

    typedef struct/union Mystruct  mys;
    typedef struct Mystruct
    {
    	int num;
    	float f1;
    }mys;
    

    共同体

    共用体地址

    对于共用体而言,所有成员地址都是一样的

    共用体size

    共用体宽度是最长的那个,但是必须整除最宽

    Union Mynion
    {
    		char str[13];
    		double num;//size为16,因为要整除
    }
    

    共用体变量定义分配内存,长度等于最长成员所占字节数

    最宽字节

    字节对齐属性设置和成员中的最宽,取较小的为最宽
    结构体嵌套的情况下,最宽基本成员不局限于当前结构体。

    共用体初始化

    #include<stdio.h>
    #include<stdlib.h>
    #include<Windows.h>
    
    union pc
    {
    	int num;
    	char price[10];//字符串数组
    	char *p;//指针
    };
    
    void main()
    {
    	union pc p1 = { 1000 };
    	union pc p2[2] = { {1000},{1000} };
    	//union pc *p = (union pc[]){ {1000}, { 1000 }, {1000} };
    	system("pause");
    }
    

    位域

    位域,限制数据的位数,节约内存

    struct Mystruct
    {
    	unsigned int a:5;//位域,限制数据的位数,节约内存
    	unsigned int b:4;//需要注意符号位
    	unsigned int c:16;
    }//输出size大小是4个字节
    2.	多个数据进行重合,按照类型进行重合。
    3.	如果类型不一致,遵顼结构体的对齐规则,通过设置对齐方式可以进行内存优化
    Struct data
    {
    	unsigned char a:1;//位域,限制数据的位数,节约内存
    	unsigned char b:1;
    }//输出size大小是1个字节
    与
    Struct data
    {
    	unsigned short a:1;//位域,限制数据的位数,节约内存
    	unsigned short b:1;
    }//输出size大小是2个字节
    

    实战

    在这里插入图片描述

    低位在低字节,高位在高字节

    在这里插入图片描述

    展开全文
  • C++struct结构体的用法

    2019-10-31 14:32:59
    struct Person{ // Peson 为结构体标志 int age; string name; }person_a, person_b; // 声明之后直接创建变量 struct Person person_c; // 需要的时候创建 有 typedef 的声明方式 typedef struc...
  • C和C++中得结构体

    2014-09-18 23:32:27
    C/C++语言中的解释 结构体定义  结构体(struct)是由一系列具有相同类型或不同类型的数据构成的数据集合,也叫结构。 结构体作用  结构体和其他类型基础数据类型一样,例如int类型,char类型 只不过结构体可以...
  • 最近做的项目,需要在C# 中调用C++ 写的DLL,因为C# 默认的编码方式是Unicode,而调用的DLL规定只处理UTF8编码格式的字符串,DLL中的输入参数类型char*被我Marshal成byte[],输出参数类型char**被我Marshal成了string...
  • c++ c#结构体调用

    千次阅读 2012-10-20 17:15:20
    1、最近做项目遇到,C#调用C++dll里的函数需要传递结构体参数,发现这个并不是简单的在C#里定义相应的结构体就可以的,下面以一个例子来说明解决的办法,C++中的函数和结构体如下: uint msec_set_igr_gen_cfg...
  • c++结构体作为函数参数的使用

    千次阅读 2018-04-09 11:51:03
    结构体虽然和数组一样,都可以存储多个数据项,但是在涉及到函数时,结构变量的行为更接近于一个基本的单值变量,也就是说,与数组不同,结构将其数据组合成单个实体或数据对象,该实体被视为一个整体。函数中参数为...
  • 本文主要是谭浩强老师c++教材第三版第七章的小结。 1.结构体的定义及初始化 定义结构体的目的是反映数据之间的内在联系。 声明结构体的一般形式为: struct 结构体类型名  {成员表} 其中,成员表由每个成员的...
  • C++结构体与类到底有什么区别

    千次阅读 2018-06-25 21:12:02
    从上述代码可以看出Struct与Class好像根本没有区别,网上说类是引用类型,结构体是值类型,但是发现一个问题不管是结构体和类的实例化对象都可以随意存在堆上或者栈上,变量名和指针一定是存在栈上的,但是具体的...
  • 最近做的项目,需要在C# 中调用C++ 写的DLL,因为C# 默认的编码方式是Unicode,而调用的DLL规定只处理UTF8编码格式的字符串,DLL中的输入参数类型char*被我Marshal成byte[],输出参数类型char**被我Marshal成了string...
  • C++结构体

    2020-11-03 14:05:09
    结构体(struct)是一个由程序员定义的数据类型,可以容纳许多不同的数据值。在过去,面向对象编程的应用尚未普及之前,程序员通常使用这些从逻辑上连接在一起的数据组合到一个单元中。一旦结构体类型被声明并且其...
  • [C++]结构体、共同体和枚举类型

    千次阅读 2016-11-30 22:49:49
    1、结构体类型的变量在内存依照其成员的顺序顺序排列,所占内存空间...3、对结构体中各个成员可以单独引用、赋值,其作用与变量等同。 格式:变量名 . 成员名 student1 . num 4、结构体的成员可以是另一个结构体类型。
  • 结构体定义 以下面的代码为例typedef struct pe{ char name[10]; char sex[2]; int age; bool operator ==(const pe &p) //"=="运算符重载,重载在结构体内 { return(p.name==name&&p.sex==sex&&...
  • 文章目录1 C语言的结构体1.1 声明和定义1.2 C结构体使用1.3 与C++结构体的不同2 C++结构体2.1 声明和定义2.1.1比C结构体多了什么2.1.2 声明 1 C语言的结构体 1.1 声明和定义 基本形式: struct type{ int num; char...
  • C/C++结构体(struct)知识点强化为了进一部的学习结构体这一重要的知识点,我们今天来学习一下链表结构。  结构体可以看做是一种自定义的数据类型,它还有一个很重要的特性,就是结构体可以相互嵌套使用,但也...
  • 一个结构体变量的指针就是该变量所占据的内存段的起始地址。可以设一个指针变量,用来指向一个结构体变量,此时该指针变量的值是结构体变量的起始地址。指针变量也可以用来指向结构体数组中的元素。 声明一个...
  • C++结构体和类可以通用 什么是结构体? 简单的来说,结构体就是一个可以包含不同数据类型的一个结构,它是一种可以自己定义的数据类型,它的特点和数组主要有两点不同,首先结构体可以在一个结构中声明不同的...
  • //③①引用返回 struct _hero update31(struct _hero &name){ name.level++; return name; } int main(){ larry.level = 1; //--------①-------- update(larry); cout<<larry.level<<endl;...
  • 这两天在用C++写仿真代码时,用到了大量的结构体,但是最后的结果总是出错或者编译运行时就会出现错误。经过在网上查阅大量资料和博客,发现是因为使用结构体时没有考虑内存的分配。而在定义结构体这种数据类型的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 33,645
精华内容 13,458
关键字:

c++返回结构体引用

c++ 订阅