C++——多态、异常、转化函数

最新推荐文章于 2023-04-20 14:58:10 发布
最新推荐文章于 2023-04-20 14:58:10 发布
阅读量694 收藏
点赞数
分类专栏： C++/QT 文章标签： 嵌入式 vim qt c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52479948/article/details/128720749
版权

目录

一、多态

二、异常

​三、转换函数

3.1标准转换函数

3.2自定义转换函数

3.3隐式转换（explicit）

封装Thread类

一、多态

c++支持用基类的指针指向派生类。

 

 

#include <iostream>

using namespace std;

class A{
public:
	A(){ }
    ~A(){ cout<<"A~~~~~~~~~"<<endl; }
	
    void show()
	{
		cout<<"AAAAAAAAAAAAA"<<endl;
	}
	
};

class AX:public A{
public:
	~AX(){ cout<<"AX~~~~~~~~~"<<endl; }
	void show()
	{
		cout<<"BBBBBBBBBBBBB"<<endl;
	}
	
};

int main()
{
//	AX a;

//	AX *p = new AX;
//	delete p;

	//A *p = new AX;
	//delete p;
/*
	A a;
	a.show();

	AX b;
	b.show();
*/

#if 1
	AX a;
	AX *q = &a;
	A  *p = &a;

	q->show();
	p->show();
#endif
}

谁的指针就show谁，他们指向的都是派生类的对象，但是真正执行按指针来。

谁先结束谁先执行析构函数

当我们把基类写成虚函数后，就变成了认对象不认指针。

#include <iostream>

using namespace std;

class A{
public:
	A(){ }
    ~A(){ cout<<"A~~~~~~~~~"<<endl; }
	
    virtual void show()
	{
		cout<<"AAAAAAAAAAAAA"<<endl;
	}
	
};

class AX:public A{
public:
	~AX(){ cout<<"AX~~~~~~~~~"<<endl; }
	void show()
	{
		cout<<"BBBBBBBBBBBBB"<<endl;
	}
	
};

int main()
{
//	AX a;

//	AX *p = new AX;
//	delete p;

	//A *p = new AX;
	//delete p;
/*
	A a;
	a.show();

	AX b;
	b.show();
*/

#if 1
	AX a;
	AX *q = &a;
	A  *p = &a;

	q->show();
	p->show();
#endif
}

 加上virtual就变成了动态选择，这就是多态

百度百科-验证

 ：初始化只有构造函数可以用

使用一个基类限制所有派生类接口形式（基类指针取出派生类对象）

 

#include <iostream>
using namespace std;

class shape{
public:
    virtual double getC(void){
    
    }
};

class Cir:public shape{
public:
    Cir(double ri):r(ri) {}
    double getC(void)
    {
        return 2*r*3.14;
    }
    int r;
};
class Tri:public shape{
public:
    Tri(double a, double b, double c):e1(a), e2(b), e3(c){ }

    double getC(void)
    {
        return e1 + e2 + e3;
    }
private:
    double e1;
    double e2;
    double e3;
};

class Rec: public shape{
public:
    Rec(double e)
    {
        this->e = e;
    }
    double getC(void)
    {
        return 4*e;
    }
private:
    double e;
};

double countC(shape *arr[], int n)
{
    double sum = 0;
    for(int i = 0; i < n; i++)
    {
        sum += arr[i]->getC();
    }
    return sum;
}
int main()
{
    Cir c(1);
    Rec r(3);
    Cir c1(2);
    Tri t(3,3,3);
    
    shape *arr[] = {&c, &r, &c1, &t};

    cout << "total C:" << countC(arr, 4) << endl;
}

我们修改一下

编译不通过了，以为shape被我们写成了纯虚函数

 

#include <iostream>
using namespace std;

class shape{
public:
    virtual double getC(void) = 0;
    //{
    
    //}
};

class Cir:public shape{
public:
    Cir(double ri):r(ri) {}
    double getC(void)
    {
        return 2*r*3.14;
    }
    int r;
};
class Tri:public shape{
public:
    Tri(double a, double b, double c):e1(a), e2(b), e3(c){ }

    double getC(void)
    {
        return e1 + e2 + e3;
    }
private:
    double e1;
    double e2;
    double e3;
};

class Rec: public shape{
public:
    Rec(double e)
    {
        this->e = e;
    }
    double getC(void)
    {
        return 4*e;
    }
private:
    double e;
};

double countC(shape *arr[], int n)
{
    double sum = 0;
    for(int i = 0; i < n; i++)
    {
        sum += arr[i]->getC();
    }
    return sum;
}
int main()
{   
    shape x;
    Cir c(1);
    Rec r(3);
    Cir c1(2);
    Tri t(3,3,3);
    
    shape *arr[] = {&c, &r, &c1, &t};

    cout << "total C:" << countC(arr, 4) << endl;
}

 

#include <iostream>

using namespace std;

class A{
public:
	A(){ }
    virtual ~A(){ cout<<"A~~~~~~~~~"<<endl; }
	
    virtual void show()
	{
		cout<<"AAAAAAAAAAAAA"<<endl;
	}
	
};

class AX:public A{
public:
	~AX(){ cout<<"AX~~~~~~~~~"<<endl; }
	void show()
	{
		cout<<"BBBBBBBBBBBBB"<<endl;
	}
	
};

int main()
{
	AX a;
    A b;
//	AX *p = new AX;
//	delete p;

	//A *p = new AX;
	//delete p;
/*
	A a;
	a.show();

	AX b;
	b.show();
*/

#if 0
	AX a;
	AX *q = &a;
	A  *p = &a;

	q->show();
	p->show();
#endif
}

 创建了两个对象但是调用了三次析构函数，再派生时调用了一次基类的构造函数

如果对象是指针的话也是对的

 

	AX *p = new AX;
	delete p;

我们改动一下

	A *p = new AX;
	delete p;

 

  居然没有任何问题。

 这样是一个不安全的行为，当我们把基类的系公平析构函数也写成虚函数的样式，它又会变得安全。

class A{
public:
	A(){ }
    virtual ~A(){ cout<<"A~~~~~~~~~"<<endl; }
	
    virtual void show()
	{
		cout<<"AAAAAAAAAAAAA"<<endl;
	}
	
};

二、异常

#include <iostream>
#include <stdlib.h>

using namespace std;

int main()
{
    int data = atoi("1234");

    cout << data << endl;
}

 

 

#include <iostream>
#include <stdlib.h>

using namespace std;

int main()
{
    int data = atoi("abcd");

    cout << data << endl;
}

 

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

using namespace std;

int myatoi(const char *str)
{
    if(*str < '0' || *str > '9')
        printf("wrong arg!!!\n");
    else
        return atoi(str);
}

int main()
{
//    int data = atoi("abcd");
    int data = myatoi("asdfas");

    cout << data << endl;
}

 依旧会把错误的值打印出来

像下面这样可以吗？

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

using namespace std;

int myatoi(const char *str)
{
    if(*str < '0' || *str > '9')
        printf("wrong arg!!!\n");
        goto xxx;
    else
        return atoi(str);
}

int main()
{
//    int data = atoi("abcd");
    int data = myatoi("asdfas");

    cout << data << endl;
xxx:
    cout << "xxxxxxxxxxxxxxxxxxx" << endl;
}

还是不行，因为C语言的goto是不能段外跳的C语言到现在都没有解决这个问题

但是C++给我们解决了

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

using namespace std;

int myatoi(const char *str)
{
    if(*str < '0' || *str > '9')
//        printf("wrong arg!!!\n");
//        goto xxx;
        throw "wrong arg!!!";
    else
        return atoi(str);
}

int main()
{
//    int data = atoi("abcd");
    try{
        int data = myatoi("asdfas");
        cout << data << endl;
    }
    catch(const char *p)
    {
        cout << p << endl;
    }
//xxx:
//    cout << "xxxxxxxxxxxxxxxxxxx" << endl;
}

 C++标准库里为我们提供了这样一个类

 

我们可以自己定义异常，下面定义一个感受感受

表达结果一样，但是这样更面向对象一点

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

using namespace std;

class argexception:public exception{
public:
    const char* what() const throw()
    {
        return "arg Err !";
    }
};

int myatoi(const char *str)
{
    if(*str < '0' || *str > '9')
        throw argexception();
    else
        return atoi(str);
}

int main()
{
    try{
        int data = myatoi("asdfas");
        cout << data << endl;
    }
    catch(argexception e)
    {
        cout << e.what() << endl;
    }
}

 三、转换函数

3.1标准转换函数

 上面两个太危险了，现在已经废弃

 

#include <iostream>

using namespace std;

int main()
{
    int a;
    char *p = &a;
}

 改成这样就过了

#include <iostream>

using namespace std;

int main()
{
    int a;
    char *p = (char*)&a;
}

下面是前两种方式

#include <iostream>

using namespace std;

int main()
{
#if 0
    int a;
//    char *p = (char*)&a;
    char *p = reinterpret_cast<char *>( &a );
#endif
    const int b = 100;
    int *q = const_cast<int *>( &b );
}


#include <iostream>

using namespace std;
class A{
public:
    virtual void show()
    {
        cout << "aaaaaaaaa" << endl;
    }
};

class B:public A{
public:
    void show()
    {
        cout << "bbbbbbbbbbb" << endl;
    }
};
int main()
{
#if 0
    int a;
//    char *p = (char*)&a;
    char *p = reinterpret_cast<char *>( &a );
#endif
#if 0
    const int b = 100;
    int *q = const_cast<int *>( &b );
#endif
#if 0
    A a;

    B &p = static_cast<B &>( a );
#endif
#if 1
    try{
        A a;
        B &p = dynamic_cast<B &>( a );
    }
    catch(bad_cast e)
    {
        cout <<e.what()<<endl;
    }
#endif

}

 

3.2自定义转换函数

 

 

#include <stdio.h>
#include <unistd.h>
#include <iostream>

using namespace std;

class Timer{
public:
	Timer()
	{
		hour = 0;
		min = 0;
		sec = 0;
	}
	~Timer()
	{

	}

	void addtimer(int sec=1)
	{
		this->min += (this->sec+sec)/60;
		this->sec = (this->sec+sec)%60;
	}

	void show()
	{
		printf("%2d:%2d:%2d\n", hour, min, sec);
	}

	Timer operator+(int sec)
	{
		Timer tem;
		tem.sec = this->sec+sec;
		return tem;
	}
	Timer operator+(Timer &x)
	{
		Timer tem;
		tem.sec = sec+x.sec;
		tem.min = min+x.min;
		tem.hour = hour+x.hour;
		return tem;
	}

	Timer operator++(int)
	{
		Timer tem = *this;//backup
	
		sec++;

		return tem;
	}

	Timer operator++()
	{
		sec++;
		return *this;
	}

	bool operator==(Timer &x)
	{
		if(sec==x.sec && min==x.min && hour==x.hour)
			return true;
		return false;
	}

	int &operator[](int i)
	{
		switch(i)
		{
		case 0: 
			return hour;
		case 1: 
			return min;
		case 2: 
			return sec;
		}
	}

    operator int()
    {
        return sec + min * 60 + hour * 60 * 60; 
    }

	friend ostream &operator<<(ostream &out, const Timer &t);
private:
	int hour;
	int min;
	int sec;
};

ostream &operator<<(ostream &out, const Timer &t)
{
	out << "hour: "<<t.hour << " min: "<<t.min<<" sec: "<<t.sec<< endl;
}

int main()
{
	Timer t;
	t.addtimer(3);
    
    int sec = t;

    cout << sec << endl;
}

 

3.3隐式转换（explicit）

 

 

 

#include <iostream>

using namespace std;

class mempool{
public:
    mempool(int size)
    {
        data = new char[size];
        cout << "cccccccccccccc" << endl;
    }
    ~mempool()
    {
        delete [] data;
    }
private:
    char *data;

};
int main()
{
    mempool a(100);
}

 

 

#include <iostream>

using namespace std;

class mempool{
public:
    mempool(int size)
    {
        data = new char[size];
        cout << "cccccccccccccc" << endl;
    }
    ~mempool()
    {
        delete [] data;
    }
private:
    char *data;

};
int main()
{
//    mempool a(100);
    mempool a = 100;
}

结果是一样的，但是我们肯定不希望这样，我们不希望通过这种方式操作内存池。

#include <iostream>

using namespace std;

class mempool{
public:
    explicit mempool(int size)
    {
        data = new char[size];
        cout << "cccccccccccccc" << endl;
    }
    ~mempool()
    {
        delete [] data;
    }
private:
    char *data;

};
int main()
{
//    mempool a(100);
    mempool a = 100;
}

 

封装Thread类

别人写的：

Thread类的封装_封装thread类_鬼才fjz的博客-CSDN博客

我修改一下：

#include "pthread.h"
#include <iostream>
using namespace std;
class Thread{
public:
    Thread() : autoDelete_(false)
    {
        cout<<"Thread ..."<<endl;
    }

    virtual ~Thread()
    {
        cout<<"~Thread ..."<<endl;
    }

    void Start()
    {
        pthread_create(&threadId_, NULL, ThreadRoutine, this);
    }

    void Join()
    {
        pthread_join(threadId_, NULL);
    }
private:
    static void* ThreadRoutine(void* arg)
    {
        Thread* thread = static_cast<Thread*>(arg);
        thread->Run();
        if (thread->autoDelete_)
            delete thread;
        return NULL;
    }
public:
    void SetAutoDelete(bool autoDelete)
    {
        autoDelete_ = autoDelete;
    }
private:
    virtual void Run() = 0;
    pthread_t threadId_;
    bool autoDelete_;
};
int main()
{

}

宇努力学习
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++ 多态（四）动态转换
jianbiancheng的博客
05-14 770
C++ 多态（四）动态转换 Dynamic casting 概述 在处理多态性时，您经常会遇到这样的情况:您有一个指向基类的指针，但您希望访问只存在于派生类中的一些信息。 考虑以下程序: #include <iostream> #include <string> class Base { protected: int m_value; public: Base(int value): m_value(value) {} vir
C++ ：多态（类型转换及问题、虚函数、C++如何实现动态绑定、多态成立的条件、抽象基类和纯虚函数、虚析构函数）
陈宸的博客
11-01 464
多态是面向对象程序设计语言中数据抽象和继承之外的第三个基本特征。 目录 一、类型转换及问题 1.2 问题解决思路 1.3 问题解决方案(虚函数,vitual function) 二、C++如何实现动态绑定 三、多态成立的条件 四、抽象基类和纯虚函数(pure virtual function) 五、虚析构函数 c++支持编译时多态(静态多态)和运行时多态(动态多态)，运算符...
类型转换（C++）
Man9o
03-09 3000
或者编译器会对常量进行优化，直接用它的值替换所有的引用，那么你修改的只是一个临时变量，而不是原来的常量。在main函数中，创建了一个B类的对象b，并将其地址分别赋给了指向A1和A2类型的指针ptr1和ptr2。reinterpret_cast可以将任何指针类型转换为任何其他指针类型，但是这种转换是不安全的，因为它不检查转换前后的指针是否兼容。这些输出的地址表明，指向A1类型的指针ptr1和指向A2类型的指针ptr2分别指向了B类对象b中不同的内存地址。每个包含虚函数的类或者虚继承的子类，都有一个虚函数表。
掌握C++类型转换：static_cast、const_cast、dynamic_cast 和 reinterpret_cast
Lion_Long的博客
04-20 5223
静态类型转换静态类型转换是最常用的类型转换方式，它可以将一种类型的数据强制转换为另一种类型，但需要注意的是，这种转换可能会损失一些信息，因此在进行此类转换时应当谨慎。int a = 10;动态类型转换动态类型转换主要用于多态类型之间的转换，它可以将基类指针或引用转换为派生类指针或引用。如果进行非法的类型转换，动态类型转换会返回一个空指针。重新解释类型转换。
c++ 定义新的异常
测试0901-1
01-22 291
#include <iostream> #include <exception> using namespace std; struct MyException : public exception { const char * what () const th...
c++实训教程——C++
03-26
6. **异常处理**：通过try、catch和throw关键字，C++提供了异常处理机制，用于处理运行时错误。 7. **文件输入输出**：C++提供了iostream库进行文件操作，包括读取和写入文本或二进制文件。 8. **命名空间**：命名...
C++课程设计——GPA计算器
08-18
C++是一种面向对象的编程语言，它允许我们创建类和对象，实现封装、继承和多态等特性。在这个GPA计算器项目中，我们将定义一个名为`GPA`的类，该类包含学生的姓名、学分、课程成绩等属性，以及计算GPA的方法。 1. ...
C++课程设计——餐厅管理系统源文件
08-18
**C++课程设计——餐厅管理系统的知识概览** 在C++课程设计中，餐厅管理系统是一个经典且实用的项目，它涵盖了面向对象编程、类的设计、文件操作、异常处理等多个核心知识点。通过这个项目，学生可以深入理解C++...
基于C++实现编译器【100012866】
最新发布
07-01
在本项目中，我们探讨的是一个基于C++实现的编译器，该编译器用于将类PASCAL语言转化为x86汇编语言。这个任务是北京航空航天大学计算机学院本科《编译原理》课程的一个实验大作业。下面将详细讨论相关知识点： 1. *...
《C++基础教程——从问题分析到程序设计》
02-04
《C++基础教程——从问题分析到程序设计》是一本旨在引导初学者深入理解C++编程语言的书籍，它不仅涵盖了C++的基础概念，还强调了如何从问题分析到程序设计的完整过程。这本书的内容丰富，包括了各种实例和练习题，...
C++ 四种类型转换
weixin_42442319的博客
08-06 902
C++中四种类型转换分别为，以下表格是对四种转换类型一个简单的汇总。注意：为什么不用C的强制转换：C的强制转换表面上看起来功能强大什么都能转，但是转换不够明确，不能进行错误检查，容易出错。............
C++之多态与类型转换
月月鸟呀的博客
05-29 495
多态 先看以下例子 #include <iostream> #include <string.h> #include <unistd.h> using namespace std; class Human { public: void eating(void) { cout<<"use hand to eat"<<endl; } }; class Englishman : public Human { public: void ea
C++中atoi()函数的用法
热门推荐
reason的博客
05-07 1万+
0 基本使用 #include<stdlib.h> #include<stdio.h> int main(void) { float n; char const *str="12345.67"; n=atoi(str); printf("string=%sfloat=%f\n",str,n); //string = 12345.67 float = 12345.000000
C++ 多态 指针转换
发展是曲折的但也是前进的
10-21 1621
class A{ public: A(); virtual ~A();};class B{ public: B(); virtual ~B();};class C : public A, public B{ public: C(); virtual ~C();}; 类型指针转换常见的错误： 1、父类指针转换成子类指针后，可能异常，因为父类指针不一定指向
C++多态与类型转换
yunchow的专栏
05-25 380
c++中字符串的处理,用string进行处理,实际上它是一个类. [code="c++"]string name; name.size(); name.c_str();[/code] 因此这里的name就是一个对象. name[下标],这样写不表示它是一个数组. char s[100] = "Hello";//应该是存在了栈空间里 char* p = "Hello";//字符串存...
C++类型转换使用场景 reinterpret_cast/const_cast/static_cast
Colin_RZL的博客
12-16 649
1、reinterpret_cast 强制类型转换 使用场景： 不同类型指针之间转换 指针和数字之间转换 函数指针之间转换 void test01() { int *ip = nullptr; // <写上要转换的目标类型>(要转换的变量) char *cp = reinterpret_cast<char*>(ip); // 转换为数字类型 int addr...
C++多态动态强制转换
qq_19300307的博客
03-04 243
dynamic_cast
C++面向对象编程：转换函数详解
"转换函数-C++面向对象程序设计(谭浩强)——教学ppt" 在C++编程中，转换函数是一个重要的面向对象特性，它允许我们自定义类对象转化为其他数据类型的逻辑。转换函数通常用于在类中定义一个成员函数，以便在需要时将...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

宇努力学习

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值