精华内容
下载资源
问答
  • 在第一节中我们就提到C语言构造类型,分为:数组、结构体、枚举、共用体,当然前面数组的内容已经说了很多了,这一节将会重点说一下其他三种类型。 结构体 枚举 共用体 结构体 数组中存储的是一系列相同的数据类型...
  • 在第一节中我们就提到C语言构造类型,分为:数组、结构体、枚举、共用体,当然前面数组的内容已经说了很多了,这一节将会重点说一下其他三种类型。
  • 常见的构造函数有三种写法:无参构造函数一般构造函数复制构造函数C++的构造函数可以有多个,创建对象时编译器会根据传入的参数不同调用不同的构造函数。1、无参构造函数如果创建一个类,没有写任何构造函数,则系统...

    4b97f616d5c1f44e9dea9e6334d068a9.png

    C++的构造函数的作用:初始化类对象的数据成员。

    即类的对象被创建的时候,编译系统对该对象分配内存空间,并自动调用构造函数,完成类成员的初始化。

    构造函数的特点:以类名作为函数名,无返回类型。

    常见的构造函数有三种写法:

    无参构造函数

    一般构造函数

    复制构造函数

    C++的构造函数可以有多个,创建对象时编译器会根据传入的参数不同调用不同的构造函数。

    1、无参构造函数

    如果创建一个类,没有写任何构造函数,则系统会自动生成默认的无参构造函数,且此函数为空。

    默认构造函数(default constructor)就是在没有显式提供初始化式时调用的构造函数。如果定义某个类的变量时没有提供初始化时就会使用默认构造函数。

    但只要有下面某一种构造函数,系统就不会再自动生成这样一个默认的构造函数。如果希望有一个这样的无参构造函数,则需要显示地写出来。

    #include

    using namespace std;

    class Student {

    public:

    int m_age;

    int m_score;

    // 1. 无参构造函数

    Student() {

    m_age = 10;

    m_score = 99;

    cout << "1. 无参构造函数" << endl;

    }

    };

    2、一般构造函数

    一般构造函数有两种写法:

    初始化列表方式:以一个冒号开始,接着是以逗号分隔的数据成员列表,每个数据成员后面跟一个放在括号中的初始化值。

    内部赋值方式:正常函数的赋值。

    #include

    using namespace std;

    class Student {

    public:

    int m_age;

    int m_score;

    // 2. 一般构造函数

    // 初始化列表方式

    Student(int age, int score) :

    m_age(age),

    m_score(score)

    {}

    // 内部赋值方式

    Student(int age, int score) {

    m_age = age;

    m_score = score;

    }

    };

    C++规定,对象的成员变量的初始化动作发生在进入构造函数本体之前。也就是说采用初始化列表的话,构造函数本体实际上不需要有任何操作,因此效率更高。

    一般构造函数可以有多种参数形式,即一个类可以有多个一般构造函数,前提是参数的个数或者类型不同(C++的函数重载机制)。

    C++覆盖和重载的区别

    #include

    using namespace std;

    class Student {

    public:

    int m_age;

    int m_score;

    // 2. 一般构造函数

    Student(int age, int score) {

    m_age = age;

    m_score = score;

    cout << "2.1 一般构造函数" << endl;

    }

    Student(int age) {

    m_age = age;

    cout << "2.2 一般构造函数" << endl;

    }

    };

    3、复制构造函数

    复制构造函数,也称为拷贝构造函数。

    复制构造函数参数为类对象本身的引用,根据一个已存在的对象复制出一个新的对象,一般在函数中会将已存在对象的数据成员的值复制一份到新创建的对象中。

    #include

    using namespace std;

    class Student {

    public:

    int m_age;

    int m_score;

    // 3. 复制构造函数

    Student(Student& s) {

    m_age = s.m_age;

    m_score = s.m_score;

    cout << "3. 复制构造函数" << endl;

    }

    };

    注意:若没有显示定义复制构造函数,则系统会默认创建一个复制构造函数,当类中有指针成员时,由系统默认创建的复制构造函数会存在“浅拷贝”的风险,因此必须显示定义复制构造函数。

    浅拷贝指的是在对对象复制时,只对对象中的数据成员进行简单的赋值,若存在动态成员,就是增加一个指针,指向原来已经存在的内存。这样就造成两个指针指向了堆里的同一个空间。当这两个对象生命周期结束时,析构函数会被调用两次,同一个空间被两次free。

    深拷贝就是对于对象中的动态成员,不是简单的赋值,而是重新分配空间。

    3b9b7005ccfa5c3bc48989f293cbf041.png

    构造函数的调用示例如下:

    int main()

    {

    Student stu1; // 调用无参构造函数

    Student stu21(21, 20); // 调用一般构造函数

    Student stu22(22); // 调用一般构造函数

    Student stu3(stu1); // 调用复制构造函数

    return 0;

    }

    展开全文
  • 概述 在第一节中我们就提到C语言构造类型,分为:数组、结构体、枚举、共用体,当然前面数组的内容已经说了很多了,这一节将会重点说一下其他三种类型。 结构体 枚举 共用体 结构体
    原文地址为:iOS开发系列--C语言之构造类型

    概述

    在第一节中我们就提到C语言构造类型,分为:数组、结构体枚举共用体,当然前面数组的内容已经说了很多了,这一节将会重点说一下其他三种类型。

    1. 结构体
    2. 枚举
    3. 共用体

    结构体

    数组中存储的是一系列相同的数据类型,那么如果想让一个变量存储不同的数据类型就要使用结构体,结构体定义类似于C++、C#、Java等高级语言中类的定义,但事实上它们又有着很大的区别。结构体是一种类型,并非一个变量,只是这种类型可以由其他C语言基本类型共同组成。

    //
    // main.c
    // ConstructedType
    //
    // Created by Kenshin Cui on 14-7-18.
    // Copyright (c) 2014年 Kenshin Cui. All rights reserved.
    //

    #include <stdio.h>

    //结构体类型Date
    struct Date{
    int year;
    int month;
    int day;
    };

    struct Person{
    char *name;
    int age;
    struct Date birthday;//一个结构体中使用了另一个结构体类型,结构体类型变量声明前必须加上struct关键字
    float height;
    };

    int main(int argc, const char * argv[]) {
    struct Person p={"Kenshin",28,{1986,8,8},1.72};
    //定义结构体变量并初始化,不允许先定义再直接初始化,例如:struct Person p;p={"Kenshin",28,{1986,8,8},1.72};是错误的,但是可以分别赋值,例如p.name="Kenshin"

    printf("name=%s,age=%d,birthday=%d-%d-%d,height=%.2f\n",p.name,p.age,p.birthday.year,p.birthday.month,p.birthday.day,p.height);
    //结果:name=Kenshin,age=28,birthday=1986-8-8,height=1.72,结构体的引用是通过"结构体变量.成员名称"(注意和结构体指针访问结构体成员变量区分,结构体指针使用p->a的形式访问)

    printf("len(Date)=%lu,len(Person)=%lu\n",sizeof(struct Date),sizeof(struct Person));
    //结果:len(Date)=12,len(Person)=32

    return 0;
    }

    对于上面的例子需要做出如下说明:

    1. 可以在定义结构体类型的同时声明结构体变量;
    2. 如果定义结构体类型的同时声明结构体变量,此时结构体名称可以省略;
    3. 定义结构体类型并不会分配内存,在定义结构体变量的时候才进行内存分配(同基本类型时类似的);
    4. 结构体类型的所占用内存大型等于所有成员占用内存大小之和(如果不考虑内存对齐的前提下);

    对第4点需要进行说明,例如上面代码是在64位编译器下运行的结果(int长度4,char长度1,float类型4),Date=4+4+4=12。但是对于Person却没有那么简单了,因为按照正常方式计算Person=8+4+12+4=28,但是从上面代码中给出的结果是32,为什么呢?这里不得不引入一个概念“内存对齐”,关于内存对齐的概念在这里不做详细说明,大家需要了解的是:在Mac OS X中对齐参数默认为8(可以通过在代码中添加#pragma pack(8)改变对齐参数),如果结构体中的类型不大于8,那么结构体长度就是其成员类型之和,但是如果成员变量的长度大于这个对齐参数那么得到的结果就不一定是各个成员变量之和了。Person类型的长度之所以是32,其实主要原因是因为Date类型长度12在存储时其偏移量12不是8的倍数,考虑到内存对齐的原因需要添加4个补齐长度,这里使用表格的形式列出了具体原因:

    memoryAlign

    表格具体来源请观看下面的视频(注意由于录制软件的原因前几秒不清晰但是不影响分析):

    接下来看一下结构体数组、指向结构体的指针:

    //
    // main.c
    // ConstructedType
    //
    // Created by Kenshin Cui on 14-7-18.
    // Copyright (c) 2014年 Kenshin Cui. All rights reserved.
    //

    #include <stdio.h>

    struct Date{
    int year;
    int month;
    int day;
    };

    struct Person{
    char *name;
    int age;
    struct Date birthday;
    float height;
    };

    void changeValue(struct Person person){
    person.height=1.80;
    }

    int main(int argc, const char * argv[]) {
    struct Person persons[]={
    {
    "Kenshin",28,{1986,8,8},1.72},
    {
    "Kaoru",27,{1987,8,8},1.60},
    {
    "Rosa",29,{1985,8,8},1.60}
    };
    for (int i=0; i<3; ++i) {
    printf(
    "name=%s,age=%d,birthday=%d-%d-%d,height=%.2f\n",
    persons[i].name,
    persons[i].age,
    persons[i].birthday.year,
    persons[i].birthday.month,
    persons[i].birthday.day,
    persons[i].height);
    }
    /*输出结果:
    name=Kenshin,age=28,birthday=1986-8-8,height=1.72
    name=Kaoru,age=27,birthday=1987-8-8,height=1.60
    name=Rosa,age=29,birthday=1985-8-8,height=1.60
    */



    struct Person person=persons[0];
    changeValue(person);
    printf(
    "name=%s,age=%d,birthday=%d-%d-%d,height=%.2f\n",
    persons[0].name,
    persons[0].age,
    persons[0].birthday.year,
    persons[0].birthday.month,
    persons[0].birthday.day,
    persons[0].height);
    /*输出结果:
    name=Kenshin,age=28,birthday=1986-8-8,height=1.72
    */


    struct Person *p=&person;
    printf(
    "name=%s,age=%d,birthday=%d-%d-%d,height=%.2f\n",
    (*p).name,
    (*p).age,
    (*p).birthday.year,
    (*p).birthday.month,
    (*p).birthday.day,
    (*p).height);
    /*输出结果:
    name=Kenshin,age=28,birthday=1986-8-8,height=1.72
    */
    printf("name=%s,age=%d,birthday=%d-%d-%d,height=%.2f\n",
    p->name,
    p->age,
    p->birthday.year,
    p->birthday.month,
    p->birthday.day,
    p->height);
    /*输出结果:
    name=Kenshin,age=28,birthday=1986-8-8,height=1.72
    */

    return 0;
    }

    结构体作为函数参数传递的是成员的值(值传递而不是引用传递),对于结构体指针而言可以通过”->”操作符进行访问。

    枚举

    枚举类型是比较简单的一种数据类型,事实上在C语言中枚举类型是作为整形常量进行处理的,通常称为“枚举常量”。

    //
    // main.c
    // ConstructedType
    //
    // Created by Kenshin Cui on 14-7-18.
    // Copyright (c) 2014年 Kenshin Cui. All rights reserved.
    //

    #include <stdio.h>

    enum Season{ //默认情况下spring=0,summer=1,autumn=2,winter=3
    spring,
    summer,
    autumn,
    winter
    };

    int main(int argc, const char * argv[]) {
    enum Season season=summer; //枚举赋值,等价于season=1
    printf("summer=%d\n",season); //结果:summer=1

    for(season=spring;season<=winter;++season){
    printf(
    "element value=%d\n",season);
    }
    /*结果:
    element value=0
    element value=1
    element value=2
    element value=3
    */
    return 0;
    }

    需要注意的是枚举成员默认值从0开始,如果给其中一个成员赋值,其它后面的成员将依次赋值,例如上面如果summer手动指定为8,则autumn=9,winter=10,而sprint还是0。

    共用体

    共用体又叫联合,因为它的关键字是union(貌似数据库操作经常使用这个关键字),它的使用不像枚举和结构体那么频繁,但是作为C语言中的一种数据类型我们也有必要弄清它的用法。从前面的分析我们知道结构体的总长度等于所有成员的和(当然此时还可能遇到对齐问题),但是和结构体不同的是共用体所有成员共用一块内存,顺序从低地址开始存放,一次只能使用其中一个成员,union最终大小由共用体中最大的成员决定,对某一成员赋值可能会覆盖另一个成员。

    //
    // main.c
    // ConstructedType
    //
    // Created by Kenshin Cui on 14-7-20.
    // Copyright (c) 2014年 Kenshin Cui. All rights reserved.
    //

    #include <stdio.h>

    union Type{
    char a;
    short int b;
    int c;
    };

    int main(int argc, const char * argv[]) {
    union Type t;
    t.a=
    'a';
    t.b=10;
    t.c=65796;

    printf(
    "address(Type)=%x,address(t.a)=%x,address(t.b)=%x,address(t.c)=%x\n",&t,&t.a,&t.b,&t.c);
    //结果:address(Type)=5fbff7b8,address(t.a)=5fbff7b8,address(t.b)=5fbff7b8,address(t.c)=5fbff7b8

    printf("len(Type)=%d\n",sizeof(union Type));
    //结果:len(Type)=4

    printf("t.a=%d,t.b=%d,t.c=%d\n",t.a,t.b,t.c);
    //结果:t.a=4,t.b=260,t.c=65796

    return 0;
    }

     

    这里需要重点解释一个问题:为什么t.a、t.b、t.c输出结果分别是4、260、65796,当然t.c等于65796并不奇怪,但是t.a前面赋值为’a’不应该是97吗,而t.b不应该是10吗?其实如果弄清这个问题共用体的概念基本就清楚了。

    根据前面提到的,共用体其实每次只能使用其中一个成员,对于上面的代码经过三次赋值最终使用的其实就是t.c,而通过上面的输出结果我们也确实看到c是有效的。共用体有一个特点就是它的成员存储在同一块内存区域,这块区域的大小需要根据它的成员中长度最大的成员长度而定。由于上面的代码是在64位编译器下编译的,具体长度:char=1,short int=2,int=4,所以得出结论,Type的长度为4,又根据上面输出的地址,可以得到下面的存储信息(注意数据的存储方式:高地址存储高位,低地址存储地位):

    union

    当读取c的时候,它的二进制是“00000000  00000001  00000001  00000100”,换算成十进制就是65796;而经过三次赋值后,此时b的存储就已经被c成员的低位数据覆盖,b的长度是二,所以从起始地址取两个字节得到的二进制数据此时是“00000001  00000100”(b原来的数据已经被c低2位数据覆盖,其实此时就是c的低2位数据),换算成十进制就是260;类似的a此时的数据就是c的低一位数据”00000100”,换算成十进制就是4。


    转载请注明本文地址:iOS开发系列--C语言之构造类型
    展开全文
  • 概述 在第一节中我们就提到C语言构造类型,分为:数组、结构体、枚举、共用体,当然前面数组的内容已经说了很多了,这一节将会重点说一下其他三种类型。 结构体 枚举 共用体 结构体 数组中存储的是一系列相同的...
    概述 

    在第一节中我们就提到C语言的构造类型,分为:数组、结构体、枚举、共用体,当然前面数组的内容已经说了很多了,这一节将会重点说一下其他三种类型。

    1. 结构体
    2. 枚举
    3. 共用体

    结构体

    数组中存储的是一系列相同的数据类型,那么如果想让一个变量存储不同的数据类型就要使用结构体,结构体定义类似于C++、C#、Java等高级语言中类的定义,但事实上它们又有着很大的区别。结构体是一种类型,并非一个变量,只是这种类型可以由其他C语言基本类型共同组成。

    //
    //  main.c
    //  ConstructedType
    //
    //  Created by Kenshin Cui on 14-7-18.
    //  Copyright (c) 2014年 Kenshin Cui. All rights reserved.
    //
    
    #include <stdio.h>
    
    //结构体类型Date
    struct Date{
        int year;
        int month;
        int day;
    };
    
    struct Person{
        char *name;
        int age;
        struct Date birthday;//一个结构体中使用了另一个结构体类型,结构体类型变量声明前必须加上struct关键字
        float height;
    };
    
    int main(int argc, const char * argv[]) {
        struct Person p={"Kenshin",28,{1986,8,8},1.72};
        //定义结构体变量并初始化,不允许先定义再直接初始化,例如:struct Person p;p={"Kenshin",28,{1986,8,8},1.72};是错误的,但是可以分别赋值,例如p.name="Kenshin"
        
        printf("name=%s,age=%d,birthday=%d-%d-%d,height=%.2f\n",p.name,p.age,p.birthday.year,p.birthday.month,p.birthday.day,p.height); 
        //结果:name=Kenshin,age=28,birthday=1986-8-8,height=1.72,结构体的引用是通过"结构体变量.成员名称"(注意和结构体指针访问结构体成员变量区分,结构体指针使用p->a的形式访问)
        
        printf("len(Date)=%lu,len(Person)=%lu\n",sizeof(struct Date),sizeof(struct Person)); 
        //结果:len(Date)=12,len(Person)=32
        
        return 0;
    }
    

    对于上面的例子需要做出如下说明:

    1. 可以在定义结构体类型的同时声明结构体变量;
    2. 如果定义结构体类型的同时声明结构体变量,此时结构体名称可以省略;
    3. 定义结构体类型并不会分配内存,在定义结构体变量的时候才进行内存分配(同基本类型时类似的);
    4. 结构体类型的所占用内存大型等于所有成员占用内存大小之和(如果不考虑内存对齐的前提下);

    对第4点需要进行说明,例如上面代码是在64位编译器下运行的结果(int长度4,char长度1,float类型4),Date=4+4+4=12。但是对于Person却没有那么简单了,因为按照正常方式计算Person=8+4+12+4=28,但是从上面代码中给出的结果是32,为什么呢?这里不得不引入一个概念“内存对齐”,关于内存对齐的概念在这里不做详细说明,大家需要了解的是:在Mac OS X中对齐参数默认为8(可以通过在代码中添加#pragma pack(8)改变对齐参数),如果结构体中的类型不大于8,那么结构体长度就是其成员类型之和,但是如果成员变量的长度大于这个对齐参数那么得到的结果就不一定是各个成员变量之和了。Person类型的长度之所以是32,其实主要原因是因为Date类型长度12在存储时其偏移量12不是8的倍数,考虑到内存对齐的原因需要添加4个补齐长度,这里使用表格的形式列出了具体原因:

    memoryAlign

    表格具体来源请观看下面的视频(注意由于录制软件的原因前几秒不清晰但是不影响分析):

    接下来看一下结构体数组、指向结构体的指针:

    //
    //  main.c
    //  ConstructedType
    //
    //  Created by Kenshin Cui on 14-7-18.
    //  Copyright (c) 2014年 Kenshin Cui. All rights reserved.
    //
    
    #include <stdio.h>
    
    struct Date{
        int year;
        int month;
        int day;
    };
    
    struct Person{
        char *name;
        int age;
        struct Date birthday;
        float height;
    };
    
    void changeValue(struct Person person){
        person.height=1.80;
    }
    
    int main(int argc, const char * argv[]) {
        struct Person persons[]={
            {"Kenshin",28,{1986,8,8},1.72},
            {"Kaoru",27,{1987,8,8},1.60},
            {"Rosa",29,{1985,8,8},1.60}
        };
        for (int i=0; i<3; ++i) {
            printf("name=%s,age=%d,birthday=%d-%d-%d,height=%.2f\n",
                   persons[i].name,
                   persons[i].age,
                   persons[i].birthday.year,
                   persons[i].birthday.month,
                   persons[i].birthday.day,
                   persons[i].height);
        }
        /*输出结果:
         name=Kenshin,age=28,birthday=1986-8-8,height=1.72
         name=Kaoru,age=27,birthday=1987-8-8,height=1.60
         name=Rosa,age=29,birthday=1985-8-8,height=1.60
         */
        
        
        
        struct Person person=persons[0];
        changeValue(person);
        printf("name=%s,age=%d,birthday=%d-%d-%d,height=%.2f\n",
               persons[0].name,
               persons[0].age,
               persons[0].birthday.year,
               persons[0].birthday.month,
               persons[0].birthday.day,
               persons[0].height);
        /*输出结果:
         name=Kenshin,age=28,birthday=1986-8-8,height=1.72
         */
        
        
        struct Person *p=&person;
        printf("name=%s,age=%d,birthday=%d-%d-%d,height=%.2f\n",
               (*p).name,
               (*p).age,
               (*p).birthday.year,
               (*p).birthday.month,
               (*p).birthday.day,
               (*p).height);
        /*输出结果:
         name=Kenshin,age=28,birthday=1986-8-8,height=1.72
         */
        printf("name=%s,age=%d,birthday=%d-%d-%d,height=%.2f\n",
               p->name,
               p->age,
               p->birthday.year,
               p->birthday.month,
               p->birthday.day,
               p->height);
        /*输出结果:
         name=Kenshin,age=28,birthday=1986-8-8,height=1.72
         */
        
        return 0;
    }

    结构体作为函数参数传递的是成员的值(值传递而不是引用传递),对于结构体指针而言可以通过”->”操作符进行访问。

    枚举

    枚举类型是比较简单的一种数据类型,事实上在C语言中枚举类型是作为整形常量进行处理的,通常称为“枚举常量”。

    //
    //  main.c
    //  ConstructedType
    //
    //  Created by Kenshin Cui on 14-7-18.
    //  Copyright (c) 2014年 Kenshin Cui. All rights reserved.
    //
    
    #include <stdio.h>
    
    enum Season{ //默认情况下spring=0,summer=1,autumn=2,winter=3
        spring,
        summer,
        autumn,
        winter
    };
    
    int main(int argc, const char * argv[]) {
        enum Season season=summer; //枚举赋值,等价于season=1
        printf("summer=%d\n",season); //结果:summer=1
        
        for(season=spring;season<=winter;++season){
            printf("element value=%d\n",season);
        }
        /*结果:
         element value=0
         element value=1
         element value=2
         element value=3
         */
        return 0;
    }

    需要注意的是枚举成员默认值从0开始,如果给其中一个成员赋值,其它后面的成员将依次赋值,例如上面如果summer手动指定为8,则autumn=9,winter=10,而sprint还是0。

    共用体

    共用体又叫联合,因为它的关键字是union(貌似数据库操作经常使用这个关键字),它的使用不像枚举和结构体那么频繁,但是作为C语言中的一种数据类型我们也有必要弄清它的用法。从前面的分析我们知道结构体的总长度等于所有成员的和(当然此时还可能遇到对齐问题),但是和结构体不同的是共用体所有成员共用一块内存,顺序从低地址开始存放,一次只能使用其中一个成员,union最终大小由共用体中最大的成员决定,对某一成员赋值可能会覆盖另一个成员。

    //
    //  main.c
    //  ConstructedType
    //
    //  Created by Kenshin Cui on 14-7-20.
    //  Copyright (c) 2014年 Kenshin Cui. All rights reserved.
    //
    
    #include <stdio.h>
    
    union Type{
        char a;
        short int b;
        int c;
    };
    
    int main(int argc, const char * argv[]) {
        union Type t;
        t.a='a';
        t.b=10;
        t.c=65796;
        
        printf("address(Type)=%x,address(t.a)=%x,address(t.b)=%x,address(t.c)=%x\n",&t,&t.a,&t.b,&t.c);
        //结果:address(Type)=5fbff7b8,address(t.a)=5fbff7b8,address(t.b)=5fbff7b8,address(t.c)=5fbff7b8
        
        printf("len(Type)=%d\n",sizeof(union Type));
        //结果:len(Type)=4
        
        printf("t.a=%d,t.b=%d,t.c=%d\n",t.a,t.b,t.c);
        //结果:t.a=4,t.b=260,t.c=65796
        
        return 0;
    }
    

     

    这里需要重点解释一个问题:为什么t.a、t.b、t.c输出结果分别是4、260、65796,当然t.c等于65796并不奇怪,但是t.a前面赋值为’a’不应该是97吗,而t.b不应该是10吗?其实如果弄清这个问题共用体的概念基本就清楚了。

    根据前面提到的,共用体其实每次只能使用其中一个成员,对于上面的代码经过三次赋值最终使用的其实就是t.c,而通过上面的输出结果我们也确实看到c是有效的。共用体有一个特点就是它的成员存储在同一块内存区域,这块区域的大小需要根据它的成员中长度最大的成员长度而定。由于上面的代码是在64位编译器下编译的,具体长度:char=1,short int=2,int=4,所以得出结论,Type的长度为4,又根据上面输出的地址,可以得到下面的存储信息(注意数据的存储方式:高地址存储高位,低地址存储地位):

    union

    当读取c的时候,它的二进制是“00000000  00000001  00000001  00000100”,换算成十进制就是65796;而经过三次赋值后,此时b的存储就已经被c成员的低位数据覆盖,b的长度是二,所以从起始地址取两个字节得到的二进制数据此时是“00000001  00000100”(b原来的数据已经被c低2位数据覆盖,其实此时就是c的低2位数据),换算成十进制就是260;类似的a此时的数据就是c的低一位数据”00000100”,换算成十进制就是4。

    展开全文
  • 重温C语言(一)数据类型之...结构体的声明并不会分配内存空间,构造类型定义变量时才会为其相应的变量分配内存空间。 1、 结构体声明、定义、初始化 第一:只有结构体定义 struct student{ char name[10]; in

    在这里插入图片描述

    一、结构体:struct

    结构体(struct)是具有相同类型或不同类型的数据构成的数据集合。

    结构体的声明并不会分配内存空间,构造类型定义变量时才会为其相应的变量分配内存空间。

    1、 结构体声明、定义、初始化

    • 第一种:结构体定义 student 类型
    struct student{
            char name[10];
            int age;
            float height;
    };
    
    • 第二种:结构体定义 student 类型 时,创建了一个结构体变量 zhangsan
    //直接带变量名zhangsan
    struct student{
            char name[10];
            int age;
            float height;
    }zhangsan;
    
    • 第三种:用匿名结构体直接定义:
    struct{
            char name[10];
            int age;
            float height;
    }zhangsan;
    
    • 第一种:只有结构体初始化
    struct{
            char name[10];
            int age;
            float height;
    }zhangsan{"张三",18,170};
    

    2、 结构体数组

    • 结构体数组定义
    struct stu{
        char *name;  //姓名
        int num;  //学号
        int age;  //年龄
        char group;  //所在小组 
        float score;  //成绩
    }class[5];
    //表示一个班有5个人
    
    • 结构体数组初始化
    struct stu{
        char *name;  //姓名
        int num;  //学号
        int age;  //年龄
        char group;  //所在小组 
        float score;  //成绩
    }class[5] = {
        {"Li ping", 5, 18, 'C', 145.0},
        {"Zhang ping", 4, 19, 'A', 130.5},
        {"He fang", 1, 18, 'A', 148.5},
        {"Cheng ling", 2, 17, 'F', 139.0},
        {"Wang ming", 3, 17, 'B', 144.5}
    };
    

    3、 结构体指针

    二、共用体:union

    1、 共用体声明、定义、初始化

    • 共用体定义
    union student{
            char name[10];
            int age;
            float height;
    };
    
    • 第一种 共用体变量定义
    union student people;
    
    • 第二种 共用体变量定义
    union student{
            char name[10];
            int age;
            float height;
    } people;
    

    2、 共用体的使用

    union data{ 
        int a;
        char b;
        int c;
    };
    
    
    int main(){
        union data data_1 = {1};//初始化时只填写一个值。(同一时间只有一个成员有效)
        data_1.b = 'c';
        data_1.a = 10;//后赋值的才有效。前面的赋值被覆盖
        //打印地址,发现指向同一个地址
        printf("%p\n%p\n%p\n",&data_1.a,&data_1.a,&data_1.a);
        return 0;
    }
    

    3、 结构体与共用体的区别

    结构体

    结构体大小是 结构体内部的成员的空间大小之和

    共用体

    共用体内存长度是内部最长的数据类型的长度。
    共用体的地址和内部各成员变量的地址都是同一个地址

    三、typedef关键字

    typedef struct{
            char name[10];
            int age;
            float height;
    }zhangsan;
    
    typedef stu1,stu2 等价于 struct stu1,stu2
    
    展开全文
  •  C语言中把构造类型分为三种:数组,结构体,枚举,下面就对它们一一学习。 1、数组  就是把相同数据类型的元素顺序排列,把有限个相同类型的变量用一个名字命名,然后用编号代表所处的位置的集合,这个名字称为...
  • 构造类型: 数组类型,结构体类型,共用体类型,枚举类型 指针类型 空类型 整数类型 整数类型即整型,C语言中又分为短整型(short),基本整型(int),长整型(long),和无符号型(unsigned)4,无符号型又细分为无符号...
  • C语言——数据类型

    2019-08-11 18:53:30
    C语言中数据类型大体可以分为这两种:基本数据类型和构造类型。由于本人才学不久,今天就只介绍一下基本数据类型。 基本数据类型又分为这三种:整数型、浮点型、字符型。 整数型: short 短整型 int 整型 long ...
  • C语言】数据类型

    2020-07-06 22:59:50
    构造类型有以下几: 数组类型 结构体类型 共用体(联合体)类型 、指针类型 指针类型的值用来表示某个变量在内存中的地址。 四、空类型 在调用函数时,通常应向调用者返回一个函数值。这个函数值是具有一定...
  • C语言的基本数据类型

    2019-05-07 21:20:35
    为Linux下C编程打基础hello world基本内置类型整型实型构造类型指针类型枚举类型void型 ...整型数据按照其存储在内存中的二进位信息为最高位是当做数值信息还是当作数据的符号位,分为以下三种。 带符号整型...
  • 2.构造类型分为数组类型、结构类型和共用类型三种。3.指针类型。在第9章中介绍。4.空类型C语言中的数据,有常量和变量之分,它们分别属于上述这些类型。本章将介绍基本类型中的整型、实型和字符型三种数据。2.3 常量...
  • 三种基本的结构及其流程图: 顺序结构:画出x=1,y=2,求输出x+2*y的流程图。 选择结构:输入x,判断x是不是闰年的流程图,x是闰年输出“yes”,x不是闰年输出“no”。 循环结构:输入x,输出所有能整除x的正整数。...
  • C语言中数据类型分为四大类型:基本数据类型构造数据类型、指针类型、空类型。其他的类型都是从这4大类型组合派生出来的。 (1)基本数据类型:其不可以再分为别的类型了。呵呵,也就是说最小的基本的类。 (2)...
  • 结构体是一种构造数据类型,可以把不同类型的数据整合在一起,每一个数据都称为该结构体类型的成员。使用结构体时,首先需要对结构体类型进行定义,结构体类型的定义如下所示: struct 结构体类型名称 { 数据...
  • C语言提供的数据结构,是以数据类型形式出现的。具体分类如下: ...分为数组类型、结构类型和共用类型三种。 3.指针类型。 4.空类型 C语言中的数据,有常量和变量之分,它们分别属于上述这些类型 ...
  • 枚举是C语言中的一基本数据类型,并不是构造类型,它可以用于声明一组常数。当一个变量有几个固定的可能取值时,可以将这个变量定义为枚举类型。比如,你可以用一个枚举类型的变量来表示季节,因为季节只有4可能...
  • C语言简介

    2021-03-29 22:30:15
    9控制语句 数据构造能力强 程序书写格式自由 运算符和数据类型丰富 程序设计结构化、模块化 生成目标代码质量高 可移植性好 C语言程序的基本结构 #include <stdio.h>//包含头文件说明 void main()...
  • 结构体和共用体C语言语法基础十——结构体、共用体和用户定义类型/*本章主要介绍:C语言中可由用户自己定义的三种数据类型**1.typedef(用户定义类型):对已有类型,另外==说明一个新的类型标识符==。*2.struct...
  • 构造类型 分为数组类型、结构类型和共用类型三种。 3.指针类型。在第9章中介绍。 4.空类型 C语言中的数据,有常量和变量之分,它们分别属于上述这些类型。 本章将介绍基本类型中的整型、实型和字符型三种数据。 [...
  • 构造类型:数组 结构体(struct) 枚举(enum) 联合(union) 指针类型:int* char* float* void* 空类型:void 整形在内存中的存储 计算机中有三种有符号的表示方法:原码,反码,补码 int a =20; 0000 000...
  • C语言结构体

    2019-02-26 15:20:59
    三种形式:数据类型、结构体类型(struct)、共用体类型(union) 一般形式: struct [结构体名] { 类型标识符 成员名; 类型标识符 成员名; … };//牢记还有一个分号 1、基本结构体 1.1、定义结构体类型变量的...
  • 计算机考研复试之C语言简答题

    千次阅读 多人点赞 2020-03-22 17:53:50
    C中的数据类型包括:基本类型、构造类型、指针类型、空类型等。 其中基本类型包括:整型、字符型、实型(浮点型)等。 C语言中十进制、八进制和十六进制整常量是如何表示的? 整型常量即整常数。C整常数可用以下...
  • 这种机制会为类型的实例化提供了一更好的内存管理方法,从而避免了在C语言中经常出现的内存泄漏和指针相关的问题。 基于堆的内存分配  在C语言中,这种内存分配指用malloc和realloc函数分配的内存空间。基于堆...
  • 、C++学习_面向对象(带C语言基础) 面向对象编程 所谓面向对象就是基于对象概念,以对象为中心,以类和继承为构造机制,来认识、理解和刻画客观世界和设计、构建相应的软件系统(模拟现实)。 对象:由数据和容许...
  • ------- android培训、java培训、iOS培训、.Net培训、期待与您...C语言构造类型:  由一个或者多个已定义类型的元素用构造的方法,构造新的类型 构造类型有三种:  数组类型 结构体类型 共用体(联合)类型 其中,

空空如也

空空如也

1 2 3 4 5 ... 13
收藏数 241
精华内容 96
关键字:

c语言构造类型三种

c语言 订阅