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

    2018-07-10 17:25:20
    类型别名:为已有类型另外命名 typedef 已有类型名 新类型名表 例: typedef double Area, Volume; typedef int Natural; Natural i1,i2; Area a; Volume v; using 新类型名 = 已有类型名; 例: us...

    类型别名:为已有类型另外命名

    • typedef 已有类型名 新类型名表

      例:

    typedef double Area, Volume;
            typedef int Natural;
            Natural i1,i2;
            Area a;
            Volume v;
    • using 新类型名 = 已有类型名;

      例:

         using Area = double;
         using Volume = double;

    枚举类型

    • 定义方式:

    将全部可取值一一列举出来。

    • 语法形式:

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

    例:enum Weekday {SUN, MON, TUE, WED, THU, FRI, SAT};

    默认情况下

    SUN=0,MON=1,TUE=2,……,SAT=6

    C++包含两种枚举类型:

    • 不限定作用域枚举类型:
      enum 枚举类型名 {变量值列表};

    • 限定作用域的enum类将在第4章介绍。

    不限定作用域枚举类型说明:

    • 枚举元素是常量,不能对它们赋值

      例如有如下定义
      enum Weekday {SUN, MON, TUE, WED, THU, FRI, SAT};

      不能写赋值表达式:SUN = 0

    • 枚举元素具有默认值,它们依次为: 0,1,2,……。

    • 也可以在声明时另行指定枚举元素的值,如:

      enum Weekday{SUN=7,MON=1,TUE,WED, THU,FRI,SAT};
      
    • 也可以在声明时另行指定枚举元素的值;

    • 枚举值可以进行关系运算。

    • 整数值不能直接赋给枚举变量,如需要将整数赋值给枚举变量,应进行强 制类型转换。

    • 枚举值可以赋给整型变量。

    *

    auto类型与decltype类型*

    • auto:编译器通过初始值自动推断变量的类型

      例如:auto val = val1 + val2;

      如果val1+val2是int类型,则val是int类型;

      如果val1+val2是double类型,则val是double类型。

    • decltype:定义一个变量与某一表达式的类型相同,但并不用该表达式初始化变量

      例如:decltype(i) j = 2;

    展开全文
  • c++自定义类型转换

    2021-01-09 11:40:39
    一:C++的内置类型和用户自定义类型的互相转换 1.内置类型转换为自定义类型。 需要使用转换构造函数。 带单参数的构造函数(基本数据类型=>自定义数据类型) 这类构造函数称为转换构造函数。 class ...

    一:C++的内置类型和用户自定义类型的互相转换

    1.内置类型转换为自定义类型。   需要使用转换构造函数。

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

    这类构造函数称为转换构造函数。

    class Complex  
    {  
    public:  
        Complex():ele1(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

    • explicit constructors:
      在你不想隐式转换,以防用户误操作怎么办?
      C++提供了一种抑制构造函数隐式转换的办法,就是在构造函数前面加explicit关键字,再隐式转换就会导致编译失败,但是,显式转换还是可以进行。

    2.自定义类型转换为内置类型。   需要使用类型转换函数。

    类型转换函数:

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

    示例代码:

    #include <iostream>
    using namespace std;
    class test {
    	int a;
    	string b;
    public:
    	test(int a) {
    		this->a = a;
    	}
    	test(string b) {
    		this->b = b;
    	}
    	//转换为int的类型转换函数
    	operator int() {
    		return a;
    	}
    	//转换为string的类型转换函数
    	operator string() {
    		return b;
    	}
    };
    int main() {
    	//test转为int
    	test t(1);
    	int a = t;
    	cout << a << endl;
    
    	//test转为string
    	test t1("hello world");
    	string str = t1;
    	cout << str << endl;
    }

     

    二:用户自定义类型之间的相互转换。

     现在很多时候,一个对象的类型转换往往需要创建一个无名的临时对象来暂存。(  临时对象可以隐含发生,也可以显式调用用户设置的构造函数。)

     c++中可以通过构造函数,来自定义类型之间的转换。一个构造函数,只要一个参数调用,那么他就设置了一种从参数类型到这个类类型的类型转换。

    程序示例:

    #include <iostream>
    #include <cmath>
    using namespace std;
    class Point {	        //Point类定义
    public:
    	Point(int xx = 0, int yy = 0) {
    		x = xx;
    		y = yy;
    	}
    	Point(const Point& p);
    	int getX() { return x; }
    	int getY() { return y; }
    
    private:
    	int x, y;
    };
    Point::Point(const Point& p) {	//复制构造函数的实现
    	x = p.x;
    	y = p.y;
    	cout << "calling the copy constructor of point" << endl;
    };
    //类的组合
    class Line {	//Line类的定义
    public:	//外部接口
    	Line(Point xp1, Point xp2);
    	Line(Line& l);
    	double getLen() { return len; }
    private:	//私有数据成员
    	Point p1, p2;	//Point类的对象p1,p2
    	double len;
    };
    //组合类的构造函数
    Line::Line(Point xp1, Point xp2) : p1(xp1), p2(xp2) {
    	cout << "Calling constructor of Line" << endl;
    	double x = static_cast<double>(p1.getX() - p2.getX());
    	double y = static_cast<double>(p1.getY() - p2.getY());
    	len = sqrt(x * x + y * y);
    }
    Line::Line(Line& l) : p1(l.p1), p2(l.p2) {  //组合类的复制构造函数
    	cout << "Calling the copy constructor of Line" << endl;
    	len = l.len;
    }
    
    int main() {
         //下面三种写法完全等效
    	cout<<Line ((Point)1,(Point)2).getlen(); 
        cout<<Line(static_cast<Point>(1),static_cast<Point>(2)).getlen();
        cout<<Line(1,2).getlen(); //这个是隐式类型转换,上面两个其实式显式类型转换 
    	
    }

    但是如果我不想用户万一误操作调用隐式构造怎么办?

    在构造函数前加上explicit关键字修饰,这样就只能显示转换,使用隐式转换就会报错。

    explicit Point(int xx = 0, int yy = 0) {
            x = xx;
            y = yy;
        }

     

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

    2021-02-08 12:54:49
    利用函数模板完成对自定义类型的数组的一些简陋操作 #include<iostream> #include<string> using namespace std; template<class T>//类模块 class Array { public: Array(int n)//构造函数 { ...

    利用函数模板完成对自定义类型的数组的一些简陋操作

    #include<iostream>
    #include<string>
    using namespace std;
    template<class T>//类模块
    class Array
    {
    public:
    	Array(int n)//构造函数
    	{
    		m_capacity = n;
    		this->m_size = 0;
    		p = new T[n];
    	}
    
    	Array(const Array& a)//拷贝构造函数:防止浅拷贝
    	{
    		this->m_capacity = a.m_capacity;
    		this->m_size =a.m_size;
    		this->p = new T[a.m_capacity];
    		for (int i = 0; i < a.m_size; ++i)
    			this->p[i] = a.p[i];
    	}
    
    	bool operator==(const Array& a)//重载==:为了判断是否是自身==自身
    	{
    		if (this->m_capacity != a.m_capacity || this->m_size != a.m_size)
    			return false;
    		for (int i = a.m_size; i < a.m_size; ++i)
    			if (this->p[i] != a.p[i])
    				return false;
    		return true;
    	}
    
    	Array& operator=(const Array& a)//重载=:深拷贝
    	{
    		if (*this == a)//若是自身等于自身,则直接返回自身
    			return *this;
    		if (this->p != NULL)//先判断原来堆区中是否有数据,若有数据则先释放
    		{
    			delete[] p;
    			p = NULL;
    			this->m_capacity = 0;
    			this->m_size = 0;
    		}
    		this->m_capacity = a.m_capacity;
    		this->m_size = a.m_size;
    		this->p = new T[a.m_capacity];
    		for (int i = 0; i < a.m_size; ++i)
    			this->p[i] = a.p[i];
    		return *this;
    	}
    
    	T& operator[](int index)//重载[]:达到利用下标可以访问元素
    	{
    		
    		if (index >= m_size)
    			cout << "溢出!";
    		return this->p[index];
    	}
    
    	void Create(const T &x)//尾插法
    	{
    		if (this->m_size == this->m_capacity)
    		{
    			cout << "数组容量已满,无法再插入" << endl;
    			return;
    		}
    		this->p[this->m_size] = x;
    		++m_size;
    	}
    
    	void deleteArray()//尾删法
    	{
    		if (this->m_size == 0)
    		{
    			cout << "数组为空" << endl;
    			return;
    		}
    		--this->m_size;
    	}
    
    	int getsize()//获得大小
    	{
    		return m_size;
    	}
    
    	int getcapacity()
    	{
    		return m_capacity;//获得容量
    	}
    
    	~Array()//析构
    	{
    		if (p != NULL)
    		{
    			delete [] p;
    			p = NULL;
    		}
    	}
    private:
    	int m_size;//大小
    	int m_capacity;//容量
    	T* p ;//指向数组
    };
    int main()//测试案列可以自定义一个类来进行测试,此处粗略测试一下
    {
    	Array<char> a(10);
    	Array<char> b(1000);
    	b = a;
    	b.Create(97);
    	cout << b[1];
    }
    
    展开全文
  • C++自定义类型比较

    2020-07-14 10:22:43
    operator适用于容器比较和sort函数 struct Node{ string name;... 自定义比较函数 适用于sort排序函数 struct Node{ string name; int value; }; bool comp(Node a,Node b){ return a.value ;//from small to big }

    operator<

    适用于容器比较和sort函数

    struct Node{
        string name;
        int value;
        bool operator<(const Node& node2)const{
            return value<node2.value;   //if value is smaller,Node is smaller
        }
    };

    或者

    struct Node{
        string name;
        int value;
    };
    bool operator<(Node node1,Node node2){
        return node1.value<node2.value;   //if value is smaller,Node is smaller
    }

    operator()()

    适用于容器比较

    struct cmp{
        bool operator()(Node a,Node b){
            return a.value < b.value;//from small to big
        }
    };

    自定义比较函数

    适用于sort排序函数

    struct Node{
        string name;
        int value;
    };
    bool comp(Node a,Node b){
        return a.value < b.value;//from small to big
    }

     

    展开全文
  • 我们在写自己定义类型时往往需要重载双目运算符,比如自己实现String类型,如果你希望使用cout<<输出String类型,就需要重载<<运算符,你可能会这么写重载: class String { private: char* str; int ...
  • C++传递自定义类型作为参数到Qml 具体请访问https://www.jianshu.com/p/bc3ac5b4b528
  • #include &lt;iostream.h&gt; #include &lt;list&gt; class animal{ virtual void attack(){ cout &lt;&lt; "动物攻击!" &lt;&lt; endl; } ..."
  • hash_set c++总结(自定义类型stuct、class)。总结自定义struct、class三个案例。find函数测试,hash_set迭代器。
  • c++自定义数据类型

    2020-06-25 21:21:41
    c++自定义数据类型(typedef、enum、struct、union) 1. typedef 作用:给基本类型名起别名 //example typedef int myint; int a = 10; myint b = 10; //both a and b are int //output 作用:针对某个量只有几种固定...
  • 目录标准类型转换为自定义类型创建带标准数据类型形参的构造函数重载 = 运算符自定义数据类型转为标准数据类型 类型转换为编程提供了方便的接口,c++的标准数据类型已经预设了一些转换,比如你可以使用 int a = 1.0 ...
  • 1.自定义类型 struct Student{ int id; string name; Student(); Student(int ID,string Name){ id=ID; name=Name; } friend ostream & operator << (ostream &out,const Student &s) ...
  • 给出优先队列中对于基本类型和自定义类型的使用
  • C++自定义数据类型的转换

    千次阅读 2017-06-27 15:08:35
    对于用户自定义的类类型,编译系统不知道如何进行转换(不能像基本数据类型(如,int、double)一样来进行显式或者隐式转换)所以需要定义专门的函数来告诉编译系统改如何转换,要用到 带单参数的构造函数(基本数据...
  • C++自定义类赋值

    2021-03-11 16:37:05
    自定义如果需要赋值操作的话,需要定义拷贝构造函数和重载=符号; 记住后来新加的成员变量也要添加赋值操作。(吃了这个亏,调了一下午)
  • C++自定义数据类型之指针

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

    千次阅读 2017-07-01 15:42:54
    C++除了提供多种基本的数据类型(如int、float、double、char等)供用户使用外,还允许用户根据需要自己声明一些类型,例如数组、结构体(structure)类型、共用体(union)类型、枚举(enumeration)类型、类(class)类型等...
  • C++自定义数据类型之数组

    千次阅读 2015-02-20 09:52:04
     数组是数目固定,类型相同的若干变量的有序集合。  数组的定义格式: [][]... 带有n个[]的为n维数组。方括号中的表示维数的大小,它也可以是一个常量表达式。  数组元素的表示: [][]...  数组下标规定为从0...
  • 这篇文章讲述了c++自定义类型的运算。是小编结合C++培训课程中的知识总结出来的,希望可以帮助到同学们! 一:首先说明下成员函数和非成员函数的区分 class A { public: void f1(){}; // 这个就是成员函数。 void ...
  • 自定义类型需要重写仿函数,告诉队列应该怎么比较 下面进行了一个测试 struct Node { int a; int b; Node(int x = 0, int y = 0) :a(x), b(y) {} }; struct cmp { bool operator()(Node n1, Node n2) { if ...
  • 除此之外,还有一些其它类型的用户自定义数据类型:   定义自己的数据类型 (typedef) C++ 允许我们在现有数据类型的基础上定义我们自己的数据类型。我们将用关键字typedef来实现这种定义,它的形式是: typedef...
  • Point3D d3 (d2); //显式调用
  • c++自定义数据类型排序
  • C++ STL: map自定义键值类型

    万次阅读 多人点赞 2018-09-29 19:11:00
    相关内容: C++ STL: unordered_map自定义键值类型 本章目录 1. map定义 2. 简单方法: 重载operator&amp;lt;()操作符 3. 其它方法:自定义compare函数 3.1 方法1: 利用std::function 3.2 方法2: 比较函数的...
  • 下面小编就为就大家带来一篇初学C++自定义类型名简化详解。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 但是如果使我们自定义类型的怎么办,在C++我们可以通过重载operator typename()来实现。 下面是代码: #include <iostream> #include <cstdio> #include <algorithm> using namespace...
  • C++中创建自定义类型的数组的方式有三种,我们分别进行表述:1、使用new运算符直接在堆中创建://使用A的默认构造函数,然后对其进行赋值操作 A* a=new A[size]; A* a=new A[size]();a[0]=A(); a[1]=A(arguments); ....
  • C++:list容器自定义类型排序

    千次阅读 2019-03-17 15:52:46
    #include &lt;iostream&gt; #include &lt;list&gt; #include &lt;string&gt; using namespace std; class Person { public: Person(string name, int age, int hight) ......
  • 类里面重载一些->操作符

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 191,482
精华内容 76,592
关键字:

c++自定义类型

c++ 订阅