C++来自派生类和基类的来回转换
C++中的派生类和基类之间的来回转换是指将派生类对象转换为基类对象，或将基类指针或引用转换为派生类指针或引用的操作。
在C++中，派生类可以继承基类的成员变量和成员函数，并且可以添加自己的成员变量和成员函数。派生类对象可以被视为基类对象的一种特殊形式，因此可以将派生类对象转换为基类对象。
派生类对象转换为基类对象的过程是隐式的，即无需进行任何特殊的操作。这是因为派生类对象包含了基类对象的所有成员，所以可以直接将派生类对象赋值给基类对象。
示例代码如下：
class Base {
public:
int baseVar;
void baseFunc() {
// 基类成员函数的实现
}
};
class Derived : public Base {
public:
int derivedVar;
void derivedFunc() {
// 派生类成员函数的实现
}
};
int main() {
Derived derivedObj;
Base baseObj = derivedObj; // 派生类对象转换为基类对象
return 0;
}在上述示例中，派生类Derived继承了基类Base的成员变量baseVar和成员函数baseFunc，并添加了自己的成员变量derivedVar和成员函数derivedFunc。在main函数中，将派生类对象derivedObj赋值给基类对象baseObj，这是一种派生类到基类的隐式转换。
除了将派生类对象转换为基类对象外，还可以将基类指针或引用转换为派生类指针或引用。这种转换需要使用dynamic_cast运算符，它可以在运行时检查指针或引用的类型，并进行相应的转换。
示例代码如下：
Base* basePtr = new Derived(); // 基类指针指向派生类对象
Derived* derivedPtr = dynamic_cast<Derived*>(basePtr); // 基类指针转换为派生类指针
if (derivedPtr != nullptr) {
// 转换成功，可以使用派生类指针访问派生类的成员
derivedPtr->derivedFunc();
}
delete basePtr;在上述示例中，首先创建了一个基类指针basePtr，并将其指向派生类对象。然后使用dynamic_cast运算符将基类指针basePtr转换为派生类指针derivedPtr。如果转换成功，则可以使用派生类指针derivedPtr访问派生类的成员函数derivedFunc。
需要注意的是，派生类到基类的转换是安全的，因为派生类对象包含了基类对象的所有成员。而基类到派生类的转换需要使用dynamic_cast运算符进行类型检查，因为基类对象可能不包含派生类特有的成员。
总结起来，C++中的派生类和基类之间的来回转换是一种重要的面向对象编程特性，它可以实现多态性和代码的灵活性。通过派生类对象转换为基类对象，可以实现基类对象的复用和派生类对象的统一处理；通过基类指针或引用转换为派生类指针或引用，可以实现派生类对象的特定操作。这种转换在实际开发中广泛应用于面向对象的设计和编程中。
腾讯云相关产品和产品介绍链接地址：
- 腾讯云云服务器（CVM）：提供可扩展的计算容量，支持多种操作系统和应用场景。详情请参考：https://cloud.tencent.com/product/cvm
- 腾讯云云数据库MySQL版：提供高性能、可扩展的MySQL数据库服务，适用于各种规模的应用。详情请参考：https://cloud.tencent.com/product/cdb_mysql
- 腾讯云人工智能平台（AI Lab）：提供丰富的人工智能算法和模型，帮助开发者快速构建和部署人工智能应用。详情请参考：https://cloud.tencent.com/product/ai
- 腾讯云物联网平台（IoT Hub）：提供全面的物联网解决方案，包括设备接入、数据管理、消息通信等功能。详情请参考：https://cloud.tencent.com/product/iothub
- 腾讯云移动开发平台（MTP）：提供一站式移动应用开发和运营服务，包括应用发布、用户管理、数据分析等功能。详情请参考：https://cloud.tencent.com/product/mtp
相关·内容
2回答
在讲课期间，一些学生说这种上传和下传缺乏逻辑，是非法的。一些老师是如何感到困惑和同意的，他说他会复习，然后再做一次讲课，但是我不知道这个代码有什么问题，是否有这样的情况是非法的。
#include <iostream>
using namespace std;
class base {
public:
int a,b;
base(){
a=0;
b=1;}
};
class derived : public base {
public:
int c,d;
derived(){
c=2;
浏览 4提问于2016-03-17得票数 1
回答已采纳
给定一个由过多的派生类继承的基类，以及一个要求您通过指向每个实体的基类指针来管理这些类的程序结构。当只知道基类指针时，有没有一种简单的方法来复制整个派生对象？
环顾四周，似乎可以使用dynamic_cast调用来检查基指针是否可以转换为适当的派生类，然后使用派生类的复制构造函数复制它。然而，这并不是一个真正的最佳解决方案，部分原因是过度使用dynamic_cast，而且维护和扩展也会非常麻烦。
我遇到的另一个更优雅的解决方案是：
class Base
{
public:
Base(const Base& other);
virtual Base* getCopy();
浏览 1提问于2011-02-17得票数 41
回答已采纳
问题：
虽然我知道函数指针，但我无法理解是什么使这两个函数在Derived类中的工作方式不同：
I) StartPrintThroughFuncPtr()
(二) StartPrint()
下面是完整代码，加上注释中的输出：
#include "iostream"
class Base
{
(void)(Base::*callee)(void);
virtual void Print(){std::cout<<"Print: Base"<<std::endl;}
public:
void StartPrintT
浏览 3提问于2014-08-04得票数 2
回答已采纳
我有一个对象，它作为基类的unique_ptr存储在映射中。
class Base
{
int foo;
};
map <string, unique_ptr<Base> > Objects;
然而，这些对象实际上属于不同的子类。
class Child1 : public Base
{
int bar1;
};
class Child2 : public Base;
{
int bar2;
};
Objects.insert(make_pair("Child1", unique_ptr<Base>(new
浏览 2提问于2015-02-13得票数 0
回答已采纳
3回答
如下面的代码所示，我正在尝试将基类指针转换为派生类指针。我预期以下代码会出现编译器错误，但不会报告任何错误。还有函数"SomeMethod_2“打印值10。
#include <iostream>
using namespace std;
class Base {
public:
Base() {
cout << "Base class constructor\n";
}
};
class Derived : public Base
{
public:
int Val;
Derived()
浏览 0提问于2019-06-28得票数 1
考虑具有虚函数的类Base和来自Base的类Derived实现虚函数，但具有很少的额外私有成员。我们可以安全地将Base*指针向下转换为Derived*指针吗？
Base* base = new Derived();
Derived* derived = dynamic_cast<Derived*>(base); // Is this valid?
如果派生类除了在基类中实现虚函数之外，还包含一个额外的私有成员int _derivedNum怎么办？在向下转换基类指针后，我是否仍然可以使用派生->_派生use来访问派生类的私有成员？
浏览 1提问于2013-04-27得票数 1
回答已采纳
6回答
我有相当简单的类层次结构：
public class Base
{
//...
public virtual void AssignFrom(Base baseObj)
{
//DoSomeStuff
}
}
public class DerivedA : Base
{
//...
public override void AssignFrom(Base derivedObj)
//Wish Method would be:
//public override void AssignFrom(DerivedA d
浏览 0提问于2018-07-19得票数 3
回答已采纳
3回答
看看密码。我的界面是这样的：
class Abstract_base {
public:
virtual ~Abstract_base() {}
virtual void f1 () = 0;
virtual void f2 () = 0;
};
基类如下所示：
class Base : public Abstract_base {
public:
virtual ~Base() {}
virtual void f1 () override { cout << "f1"
浏览 1提问于2014-11-18得票数 2
3回答
#include <iostream>
using namespace std;
class Base {
public:
Base() {};
~Base() {};
};
template<class T>
class Derived: public Base {
T _val;
public:
Derived() {}
Derived(T val): _val(val) {}
T raw() {return _val;}
};
int main()
{
Base * b = new Derived<int>(1);
浏览 0提问于2013-09-18得票数 33
回答已采纳
在我看来，将void(Derived::*)()转换为void(Base::*)()是非常安全的，如下代码所示：
#include <iostream>
#include <typeinfo>
using namespace std;
struct Base{
void(Base::*any_method)();
void call_it(){
(this->*any_method)();
}
};
struct Derived: public Base{
void a_method(){
cout&
浏览 1提问于2012-04-15得票数 5
回答已采纳
class Base{
common methods
};
class Derived: public Base{
private:
int a;
char* arr;
public:
Ctor
Dtor
};
int main(){
Base* B;
Derived D;
B = &D;
如何从B中提取关于D的数据成员的信息？
不要介意语法错误，我更关心的是如何获得数据成员，或者如果我有一个以上的派生类，如何组合两个派生类。
浏览 4提问于2015-05-19得票数 0
回答已采纳
可能重复：
这两种将派生类分配给基类指针的方法有什么区别？
Derived d1;
Base *b1 = &d1
Derived d2;
Base *b2 = dynamic_cast<Base*> &d2
浏览 6提问于2011-07-28得票数 4
下面是我的测试示例：
struct base {
virtual ~base(){}
int x;
};
struct derived: public virtual base {
base * clone() {
return new derived;
}
derived(): s("a") {}
std::string s;
};
int main () {
derived d;
base * b = d.clone();
derived * t = reinterpret_cast
浏览 0提问于2011-09-14得票数 6
回答已采纳
5回答
压倒一切的基本问题很少
、、、
我的基本知识没有什么问题，如果有人能解决这个问题，我会很感激的。
1：当我说base *b =新派生时，这是什么意思?为什么要这么做？我们很好地分别为类基和类派生创建对象，然后相应地调用函数。我知道这个基*b =新派生；被称为对象切片，但是为什么和何时会这样做呢？
2：我知道为什么不建议将基类对象转换为派生类对象(因为基类不知道派生类成员和方法)。我甚至在其他StackOverflow线程中读到，如果情况会这样，那么我们必须改变/重新访问我们的设计。我理解所有这些，但是，我只是好奇，有没有办法这样做呢？
class base
{
public:
void
浏览 2提问于2010-05-26得票数 2
将指针转换为指向派生类的方法的指针到基类的方法是否合法，即使基类不声明任何方法，特别是通过基类类型的对象调用的方法，如。
// works in VS 2008 and g++ 4.5.3
struct Base
{
};
struct Fuu : public Base
{
void bar(){ std::cout << "Fuu::bar" << std::endl; }
void bax(){ std::cout << "Fuu::bax" << std::endl; }
};
stru
浏览 6提问于2013-07-19得票数 2
回答已采纳
我读到了有关复制交换成语的文章，在一个例子中，交换方法是以以下方式实现的：
class Derived : public Base
{
public:
std::string title = "";
details *detail = nullptr;
void swap(Derived& lhs, Derived& rhs)
{
using std::swap;
Base& lb = static_cast<Base&>(lhs);
浏览 2提问于2018-07-29得票数 0
回答已采纳
5回答
如果我分配一个类为Derived (基类为Base)的对象，并将指向该对象的指针存储在指向基类的变量中，我如何访问Derived类的成员？
下面是一个例子：
class Base
{
public:
int base_int;
};
class Derived : public Base
{
public:
int derived_int;
};
Base* basepointer = new Derived();
basepointer-> //Access derived_int here, is it possible? If so, then
浏览 1提问于2010-03-13得票数 44
回答已采纳
3回答
重载运算符[]多态性
、、、、
class Base
{
protected:
string m_Name;
public:
virtual string Name() { return m_Name; }
virtual string Type() = 0;
virtual bool isEqual(Base* rhs) = 0 ;
};
我有一个抽象的类库。我的代码中的不同类继承自这个基类。我将这些对象存储在一个容器中(Base的指针向量)
struct Container
{
vector<Base*> vec;
int Count() { return ve
浏览 2提问于2014-04-30得票数 2
4回答
我不知道为什么这段代码会返回false。我有第一个版本的部分专门化。它不起作用，我尝试了第二个版本。这也没用。
更新:我想检查“派生”是否公开地从“基本”派生出来。
更新：
template<typename TDerived, typename TBase>
struct Derived_From
{
public:
static void constraints(TBase*, TDerived* ptr) { TBase* b = ptr; ignore(b); }
Derived_From() { void
浏览 2提问于2010-12-25得票数 8
回答已采纳
3回答
下面的情况是静态的还是动态的？因为我知道，我的指针在编译时指向的对象的类是什么，我猜它是静态的.
class Base
{
void print() const;
};
class Derived : public Base
{
void print() const;
};
int main()
{
Base base;
Base *basePtr = &base;
basePtr->print();
}
为什么我们应该使用动态绑定而不是静态呢？我不明白为什么我们应该使用虚拟函数，而不是以这种方式调用函数base.print() (对于上面的例子)。这个方法已经“理解”了
浏览 7提问于2014-05-08得票数 2
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
即时通信 IM
对象存储活动推荐
腾讯云开发者
