精华内容
下载资源
问答
  • c++自定义数据类型

    2017-01-15 17:43:36
    c++自定义数据类型的初步学习内容
  • C++自定义数据类型

    千次阅读 2019-07-03 00:54:56
    1.typedef 声明 typedef用于将一个标识符声明成某个数据类型的别名。 typedef 己有类型名 新类型名表; 其中新类型名表中可以有多个标识符,它们之间以逗号分隔。例如: typedef int natural; typedef double area, ...

    1.typedef 声明

    typedef用于将一个标识符声明成某个数据类型的别名。

    typedef 己有类型名   新类型名表;

    其中新类型名表中可以有多个标识符,它们之间以逗号分隔。例如:

    typedef int natural;

    typedef double area, volume;

    2.枚举类型-enum(枚举类型实际上是对整数的集合)

    当某一类数据只有有限的几种可能值时,可以采用枚举类型来表示。

    enum 枚举类型名  {变量值列表};

    例如:enum weekday {sun,mon, tue, wed, thu, fri , sat};

    应用枚举类型需要注意:

    1.对枚举元素按常量处理,不能对它们赋值。如下面是非法操作:

    sum = 0; // sun是枚举元素,此语句非法

    2.枚举元素具有默认值,他们依次为:0,1,2,……,例如上例中sun的值为0,mon为1,……,sat为6.

    3.也可以在声明时另行定义枚举元素的值,如:

    enum weekday {sun = 7,mon = 1, tue ,wed , thu, fri,sat};

    //定义sun 为7 , mon 为1, 以后顺序加1,sat为6.

    weekday result; //声明变量时,可以不写关键字enum

    enum weekday result = mon; // 也可以在类型名前写enum

    注意的是声明的变量result的取值只能是枚举类型weekday中几个值之一。

    3.结构体

    枚举类型它变量的取值是整数,如果没有给它们具体指定某一整数值,则从0开始依次递增赋值,即枚举类型其实就是一个整数的集合。但是在很多情况下,需要将一些不同类型的数据组合成一个整体。此时就需要将它声明为一个结构体类型,结构体是由不同数据类型的数据组成的集合体。下面是一个结构体的声明:

    struct student  //学生信息结构体  struct是关键字,student是结构体名称

    {

    int num ;

    char name[20];

    char sex;

    int age;

    float score;

    char addr[30];

    }stu = {97001,"Lin",‘F’,19,99.9,"street"};

    但是仅仅声明结构体类型是不够的,要使用结构体数据,还要声明结构体变量。可以通过如下方式声明一个结构体类型变量:结构名   结构变量名; 需要注意:

    结构变量声明在结构类型声明之后,二者也可以同时进行,如上例的stu;

    结构变量占用内存大小可以用sizeof运算符求出:sizeof(类型名或变量名)

    说明结构变量的同时可以直接设置初值,如上面的stu 的初值{97001,"Lin",‘F’,19,99.9,"street"};

    4.联合体

    有时需使几个不同类型的变量共用同一组内存单元,这时就可声明一个联合体类型,一个联合体声明如下:

    union uarea // union 是联合声明的关键字, uarea 是联合名

    {

    char c_data;

    short s_data;

    long l_data;

    };

    联合体类型变量说明的形式: 联合名  联合变量名;

    联合体类型变量的引用形式: 联合变量名. 成员名

    联合体可以不声明名称,称为无名联合体,只是声明一个成员项的集合,这些成员项具有相同的内存地址,可以由成员项的名字直接访问。

    union {

    int i;

    float f;

    };

    无名联合体通常用作结构体的内嵌成员。还需要注意的是联合体结构的大小问题

    解惑:sizeof(联合)这个值是怎么计算的,如下代码结果为什么是24?
    union DATE
    {
    char a;
    int i[5];
    double b;
    };
    DATE max;
    cout<< sizeof(max) << endl;
    摘几句The C Programming Language里面讲述这个问题的原话,以说明读书还是必要的:
    ①联合就是一个结构,②它的所有成员相对于基地址的偏移量都为0,③此结构空间要大到足够容纳最“宽”的成员,④并且,其对齐方式要适合于联合中所有类型的成员
    怕有的兄弟还不明白,特附图一个帮助理解:
    char a; => x
    int i[5]; => x
    x
    x
    x
    x
    x
    double b; => x
    该结构要放得下int i[5]必须要至少占4×5=20个字节。如果没有double的话20个字节够用了,此时按4字节对齐。但是加入了double就必须考虑double的对齐方式,double是按照8字节对齐的,所以必须添加4个字节使其满足8×3=24,也就是必须也是8的倍数,这样一来就出来了24这个数字。综上所述,最终联合体的最小的size也要是所包含的所有类型的基本长度的最小公倍数才行。(这里的字节数均指winnt下的值,平台、编译器不同值也有可能不同。)
    联合在存储分配的时候用的机会最多,因为很少有像存储分配这样需要给多种不同类型的变量分配空间而又打算尽可能的节约内存的,这很适合联合的特性。上述对齐的方式有个很有趣的用法也就常在存储分配里面使用。

    所以联合体的大小是能容纳它的最大成员的宽度(并且需要考虑字节对齐方式)

    unint DATE

    {

    char a;

    int i[5];

    double b;

    };

    DATE max;

    cout<<sizeof(max)<<endl; // sizeof(max) = 24

    cout<<sizeof(max.a)<<endl; //sizeof(max.a) = 1

    cout<<sizeof(max.i)<<endl; //sizeof(max.i) = 20 注意这里是20 不是4!

    cout<<sizeof(max.b)<<endl; //sizeof(max.b) = 8

    转载于:https://www.cnblogs.com/AI-Algorithms/p/3358515.html

    展开全文
  • 目录标准类型转换为自定义类型创建带标准数据类型形参的构造函数重载 = 运算符自定义数据类型转为标准数据类型 类型转换为编程提供了方便的接口,c++的标准数据类型已经预设了一些转换,比如你可以使用 int a = 1.0 ...

    类型转换为编程提供了方便的接口,c++的标准数据类型已经预设了一些转换,比如你可以使用 int a = 1.0 来将一个浮点型的数据转换为整数,可是对于那些我们自定义的数据类型,就没有那么方便了,所以需要我们自己实现

    标准类型转换为自定义类型

    将标准数据类型(比如int,float,double)转换为我们自定义的数据类型,我们希望用 a = b 这种语句来操作,有两种实现方式

    1. 创造带标准数据类型形参的构造函数
    2. 重载=运算符

    创建带标准数据类型形参的构造函数

    这种方法适用于单个形参的情况,使用以下的代码,创建cat对象,cat对象拥有age属性,通过带int参数的构造函数,我们可以直接实现 cat c = 123;这种匪夷所思的操作,不仅不会报错,还能正常执行

    #include <bits/stdc++.h>
    
    using namespace std;
    
    class cat
    {
    public:
    	int age;
    	cat(){}
    	cat(int x){age=x;}
    };
    
    int main()
    { 	
    	cat c = 2;
    	cout<<c.age;
    	
    	return 0;
    }
    

    在这里插入图片描述

    重载 = 运算符

    我们运行 cat c = 2; 本质上是调用 = 的运算符,如果我们改写这个运算符,那么就可以实现对于不同数据类型的平滑转换

    注意该方法会覆盖默认的 = 运算符,可能导致cat对象之间不能用=号赋值,所以在重载的同时,为了保险起见,我们还要从新写一个默认的=运算符的函数(但是实际上编译能够通过也能正常执行)

    #include <bits/stdc++.h>
    
    using namespace std;
    
    class cat
    {
    public:
    	int age;
    	cat(){}
    	// 保险起见要提供默认的 = 号 
    	cat& operator = (const cat& c2){age=c2.age; return *this;}
    	// 重载 = 运算符 
    	cat& operator = (const int& x){age=x; return *this;}
    };
    
    int main()
    { 	
    	cat c1,c2;
    	c1 = 2;
    	c2 = 123;
    	cout<<c1.age<<endl;
    	cout<<c2.age<<endl;
    	
    	c2 = c1;
    	cout<<c2.age<<endl;
    	
    	return 0;
    }
    
    

    在这里插入图片描述

    自定义数据类型转为标准数据类型

    自定义数据类型转为标准数据类型,需要提供强转成员函数,格式如下

    operator 类型名();
    

    无返回类型,以operator打头,然后是返回的标准数据类型名,然后括号,括号里面不能填写任何内容,但是函数体最后需要返回值,这个返回值必须和上面填的类型名一致,而且这个强转函数必须是非静态

    比如填写一个cat对象转为int对象的强转函数,应该这么声明:

    class cat
    {
    public:
    	int age;
    	cat(){age=123;}
    	operator int(){return age;}
    };
    

    执行以下代码可以实现:

    #include <bits/stdc++.h>
    
    using namespace std;
    
    class cat
    {
    public:
    	int age;
    	cat(){age=123;}
    	operator int(){return age;}
    };
    
    int main()
    { 	
    	cat c;
    	int cat_age = c;
    	cout<<cat_age;
    	
    	return 0;
    }
    

    在这里插入图片描述

    展开全文
  • 在本文中小编给大家整理了关于易语言转换到C++ 自定义数据类型问题解决办法,需要的参考一下。
  • 2013级,C++程序设计课件。第7章 自定义数据类型,内容 7.1 结构体类型 7.2 共用体 7.3 枚举类型 7.4 用typedef声明类型
  • C++自定义数据类型之指针

    千次阅读 2015-02-15 18:37:11
    好像这方面的知识理解起来很费劲儿,看了三... 要了解指针,多多少少会出现一些比较复杂的类型,所以先介绍一下如何完全理解一个复杂类型,要理解复杂类型其实很简单,一个类型里会出现很多运算符,他们也像普通的表式一样,
    
     
    

          好像这方面的知识理解起来很费劲儿,看了三四遍了吧,还是模模糊糊的,没有条理性,所以就开始翻看博客里这方面的内容,可能是看的少吧,还是不能让我彻底的明白,因此就度娘了一下,看了几篇关于指针的文章,觉得有必要去仔细的推敲。

           要了解指针,多多少少会出现一些比较复杂的类型,所以先介绍一下如何完全理解一个复杂类型,要理解复杂类型其实很简单,一个类型里会出现很多运算符,他们也像普通的表式一样,有优先级,其优先级和运算优先级一样,所以我总结了一下其原则: 从变量名处起,根运算符优先级结合,一步一步分析.下面让我们先从简单的类型开始慢慢分析吧:

     

            int p;              ///这是一个普通的整型变量

            int *p;            ///首先从P处开始,先与*结合,所以说明P是一个指针,然后再与int结合,说明指针所指向的内容的类型为int型.所以P是一个返回整型数据的指针

            int p[3];          ///首先从P处开始,先与[]结合,说明P是一个数组,然后与int结合,说明组里的元素是整型的,所以P是一个由整型数据组成的数组

            int *p[3];         ///首先从P处开始,先与[]结合,因为其优先级比*,所以P是一个数组,然后再与*结合,说明数组里的元素是指针类型,然后再与int结合,说明指针所指向的内容的类型是整型的,P是一个由返回整型数据的指针所组成的数组

            int (*p)[3];      ///首先从P处开始,先与*结合,说明P是一个指针然后再与[]("( )"这步可以忽略,只是为了改变优先级),说明指针所指向的内容是一个数组,然后再与int结合,说明数组里的元素是整型的.所以P是一个指向由整型数据组成的数组的指针

            int **p;           ///首先从P开始,先与*结合,说是P是一个指针,然后再与*,说明指针所指向的元素是指针,然后再与int结合,说明该指针所指向的元素是整型数据.由于二级指针以及更高级的指针极少用在复杂的类型中,所以后面更复杂的类型我们就不考虑多级指针了,最多只考虑一级指针

            int p(int);       ///从P处起,先与( )结合,说明P是一个函数,然后进入( )里分析,说明该函数有一个整型变量的参数然后再与外面的int结合,说明函数的返回值是一个整型数据

            Int (*p)(int);      ///从P处开始,先与指针结合,说明P是一个指针,然后与()结合,说明指针指向的是一个函数,然后再与( )里的int结合,说明函数有一个int型的参数,再与最外层的int结合,说明函数的返回类型是整型,所以P是一个指向有一个整型参数且返回类型为整型的函数的指针

            int *(*p(int))[3];    ///P开始,先与( )结合,说明P是一个函数,然后进( )里面,int结合,说明函数有一个整型变量参数,然后再与外面的*结合,说明函数返回的是一个指针,,然后到最外面一层,先与[]结合,说明返回的指针指向的是一个数组,然后再*结合,说明数组里的元素是指针,然后再与int结合,说明指针指向的内容是整型数据.所以P一个参数为一个整数据且返回一个指向由整型指针变量组成的数组的指针变量的函数.

            指针是一个特殊的变量,它里面存储的数值被解释成为内存里的一个地址。要搞清一个指针需要搞清指针的四方面的内容:指针的类型指针所指向的类型指针的值或叫指针所指向的内存区指针本身所占据的内存区

           先声明几个指针放着做例子:

           (1)int*ptr; 

           (2)char*ptr; 

           (3)int**ptr; 

           (4)int(*ptr)[3]; 

           (5)int*(*ptr)[4]; 

           1.指针的类型

           从语法的角度看,你只要把指针声明语句里的指针名字去掉,剩下的部分就是这个指针的类型。这是指针本身所具有的类型。让我们看看例一中各个指针的类型:

            (1)int*ptr;                ///指针的类型是int* 

            (2)char*ptr;           ///指针的类型是char* 

            (3)int**ptr;             ///指针的类型是int** 

            (4)int(*ptr)[3];         ///指针的类型是int(*)[3] 

            (5)int*(*ptr)[4];       ///指针的类型是int*(*)[4] 

            2.指针所指向的类型当你通过指针来访问指针所指向的内存区时,指针所指向的类型决定了编译器将把那片内存区里的内容当做什么来看待。从语法上看,你只须把指针声明语句中的指针名字和名字左边的指针声明符*去掉,剩下的就是指针所指向的类型。

    例如:

           (1)int*ptr;            ///指针所指向的类型是int 

           (2)char*ptr;           ///指针所指向的的类型是char 

           (3)int**ptr;             ///指针所指向的的类型是int* 

           (4)int(*ptr)[3];           ///指针所指向的的类型是int( )[3]

           (5)int*(*ptr)[4];          ///指针所指向的的类型是int*( )[4] 

           在指针的算术运算中,指针所指向的类型有很大的作用。指针的类型(即指针本身的类型)和指针所指向的类型是两个概念。当你对C越来越熟悉时,你会发现,把与指针搅和在一起的"类型"这个概念分成"指针的类型"和"指针所指向的类型"两个概念,是精通指针的关键点之一。我看了不少书,发现有些写得差的书中,就把指针的这两个概念搅在一起了,所以看起书来前后矛盾,越看越糊涂。

            3.指针的值----或者叫指针所指向的内存区或地址指针的值是指针本身存储的数值,这个值将被编译器当作一个地址,而不是一个一般的数值。在32位程序里,所有类型的值都是一个32位整数,因为32位程序里内存地址全都是32位长。指针所指向的内存区就是从指针的值所代表的那个内存地址开始,长度为sizeof(指针所指向的类型)的一区以后,我们说一个指针的值是XX,就相当于说该指针指向了以XX为首地址的一片内存区域;我们说一个指针指向了某块内存区域,就相当于说该指针的值是这块内存区域的首地址。指针所指向的内存区和指针所指向的类型是两个完全不同的概念。在例一中,指针所指向的类型已经有了,但由于指针还未初始化,所以它所指向的内存区是不存的,或者说是无意义的。以后,每遇到一个指针,都应该问问:这个指针的类型是什么?指针指的类型是什么?该指针指向了哪里?(重点注意)

            4指针本身所占据的内存区指针本身占了多大的内存?你只要用函数sizeof(指针的类型)测一下就知道了。在32位平台里,指针本身占据了4个字节的长度。

             指针本身占据的内存这个概念在判断一个指针表达式(后面会解释)是否是左值

    时很有用。

     

     

     

    展开全文
  • C++自定义数据类型的转换

    千次阅读 2017-06-27 15:08:35
    带单参数的构造函数(基本数据类型=>自定义数据类型) 转换函数(自定义数据类型=>基本数据类型) 来进行抽象数据类型和基本数据类型之间的转换。带单参数的构造函数(基本数据类型=>自定义数据类型)这类构造函数...

    对于用户自定义的类类型,编译系统不知道如何进行转换(不能像基本数据类型(如,int、double)一样来进行显式或者隐式转换)所以需要定义专门的函数来告诉编译系统改如何转换,要用到

    • 带单参数的构造函数(基本数据类型=>自定义数据类型)
    • 转换函数(自定义数据类型=>基本数据类型)

    来进行抽象数据类型和基本数据类型之间的转换。

    带单参数的构造函数(基本数据类型=>自定义数据类型)

    这类构造函数称为转换构造函数。
    例如:

    class Complex  
    {  
    public:  
        Complex():ele1(0.0),imag(0.0){};
        Complex(double r, double i):ele1(r),ele2(i){};  
        Complex(double r) //  转换构造函数
        {  
            ele1=r;  
            ele2=0;  
        }  
    private:  
        double ele1;  
        double ele2;  
    };  
    
    void main()
    {
        Complex c;
        c=1.2;//调用转换构造函数将1.2转换为Complex类型
    }
    • 不仅可以将一个标准类型数据转换成类对象,也可以将另一个类的对象转换成转换构造函数所在的类对象。

    • 如果不想让转换构造函数生效,也就是拒绝其它类型通过转换构造函数转换为本类型,可以在转换构造函数前面加上explicit

    类型转换函数(自定义数据类型=>基本数据类型)

    类型转换函数的一般形式为:

    operator 类型名( )
            {
                   实现转换的语句
            }

    举例:

    class Complex  
    {  
    public:  
        ...
        operator double( )  //定义类型转换函数  
        {  
             return ele1;  
        }  
    ...
    };

    注意事项:

    • 返回值的类型是由类型名来确定的。
    • 只能作为成员函数
    • 从函数形式可以看到,它与运算符重载函数相似,都是用关键字operator开头,只是被重载的是类型名。
      在示例中,double类型经过重载后,除了原有的含义外,还获得新的含义(将一个Complex类对象转换为double类型数据,并指定了转换方法)。这样,编译系统不仅能识别原有的double型数据,而且还会把Complex类对象作为double型数据处理。也就是,程序中的Complex类对具有双重身份,既是Complex类对象,又可作为double类型数据。
     void main( )  
    {
        Complex c1(1.2, 2.3);  
        double d;  
        d = c1 + 1.1; // 调用类型转换函数将c1转换为double
    }  

    转换构造函数和类型转换函数有一个共同的功能: 用户自定义后,当需要时编译系统会自动调用。

    展开全文
  • C++__自定义数据类型

    千次阅读 2017-07-01 15:42:54
    C++除了提供多种基本的数据类型(如int、float、double、char等)供用户使用外,还允许用户根据需要自己声明一些类型,例如数组、结构体(structure)类型、共用体(union)类型、枚举(enumeration)类型、类(class)类型等...
  • 除此之外,还有一些其它类型的用户自定义数据类型:   定义自己的数据类型 (typedef) C++ 允许我们在现有数据类型的基础上定义我们自己的数据类型。我们将用关键字typedef来实现这种定义,它的形式是: typedef...
  • C++自定义数据类型之联合

    千次阅读 2015-02-23 10:14:43
     联合是类型不同,数目固定的若干个变量的集合。组成联合的若干个成员是共用一个内存地址。  联合的定义格式:  union   {    };  联合变量的定义格式:  union   在定义一个联合变量之前,必须...
  • c++自定义数据类型排序
  • 实际上,自定义数据类型很简单,只需要继承torch::data::datasets::Dataset<self, SingleExample>,同时重写get(size_t index)以获取指定元素和样本总数size()即可。 Dataset类继承的定义在base.h中,它...
  • C++自定义数据类型之数组

    千次阅读 2015-02-20 09:52:04
     数组是数目固定,类型相同的若干变量的有序集合。  数组的定义格式: [][]... 带有n个[]的为n维数组。方括号中的表示维数的大小,它也可以是一个常量表达式。  数组元素的表示: [][]...  数组下标规定为从0...
  • 用户自定义数据类型包括: 类 结构体 Union(共用体) 枚举 Typedef定义的类型 类 面向对象编程的C++构建块是class,它是用户定义的数据类型,拥有自己的数据成员和成员函数,可以通过创建该类的实例来访问和...
  • 自定义数据类型如下 ------------------------------- ``` .版本 2 .数据类型 数据 .成员 坐标, 坐标_数据类型 .数据类型 坐标_数据类型 .成员 x, 小数型 .成员 z, 小数型 .成员 y, 小数型 ``` 这里的自定义...
  • C++自定义数据类型之类和简单对象

    千次阅读 2015-02-24 10:09:45
    类是C++程序中最常用的自定义数据类型。  说白了,类就是将现实世界中具有相同属性的一类客观事物的抽象,而对象就是类的一个实例,这就是对象。  类的定义格式:  类的定义格式一般分为两大部分:说明部分
  • C++ 自定义数据类型 二维数组

    千次阅读 2014-02-20 19:31:46
    C++ 二维数组 自定义数据类型 动态申请
  • ```cpp #include #include #include #include #include #include #include #include #include using namespace std;...(const all& b) const//find和count均支持,const必不可少 ...// bool operator()(c
  • C++自定义数据类型之枚举

    千次阅读 2015-02-17 18:30:59
     枚举是一种自定义数据类型,具有这种数据类型的量称为枚举常量。由于枚举常量实际上是一个int型常量,故称为枚举常量。  枚举是若干具有名字的整型常量的集合。这些整型常量组成了枚举表,枚举表中的每一项称为
  • 目录表达式与运算符运算符及其重载本质(附代码)两种重载运算符函数的方式以类成员函数的形式重载以友元函数的形式重载单目运算符的重载前++,...附代码)双目运算符的重载(附代码)cout输出自定义类型(附代码)...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 152,978
精华内容 61,191
关键字:

c++自定义数据类型

c++ 订阅