C++ 派生类c+中的向上转换变量+；

如何更改派生类中继承变量的类型？ 我有以下课程：

class Position;
class StonePosition;

class Position {
public:
    Position() {}
};

class StonePosition : public Position {
    int count;
public:
    StonePosition(const int count) { this->count = count; }
    int getCount() { return this->count; }
    void setCount(int count) { this->count = count; }
    friend ostream& operator<<(ostream&, StonePosition);
};

class Board {
protected:
    Position* crrPos;
public:
    Board() { }
    Position* getCrrPos() { return crrPos; }
    void setCrrPos(Position* pos) { crrPos=pos; }
};

class StoneBoard : public Board {
public:
    StoneBoard(const int &count) { this->crrPos=new StonePosition(count); } //<----------------
    StonePosition* getCrrPos() { return (StonePosition*)crrPos; }
    void setCrrPos(StonePosition* pos) { crrPos=pos; }
};

类位置；
阶级立场；
阶级地位{
公众：
位置（）{}
};
职位类别：公共职位{
整数计数；
公众：
StonePosition（const int count）{this->count=count；}
int getCount（）{返回此->计数；}
void setCount（int count）{this->count=count；}
friend ostream&operator变量“crrPos”不是Position类型，而是指向Position的指针类型，这很重要，因为指向Position的指针可以指向Position或从Position派生的类，而不会丢失任何内容

如果设计好类并使用虚拟函数，通常可以避免完全向上转换

#include <iostream>

class Base {
public:
    virtual void foo() { std::cout << "Base::foo()\n"; }
    virtual bool isDerived() const { return false; }
};

class Derived : public Base {
public:
    void foo() override { std::cout << "Derived::foo()\n"; }
    bool isDerived() const { return true; }
};

int main() {
    Base* crrPos = new Derived;
    crrPos->foo();
    bool isDerived = crrPos->isDerived();
    std::cout << isDerived << '\n';
    delete crrPos;
}

#包括
阶级基础{
公众：
虚拟void foo（）{std:：cout isDerived（）；
std：：cout问题已经解决，我只使用投影（（StonePosition*）Position*）：

#包括
使用名称空间std；
阶级地位；
阶级立场；
阶级地位{
公众：
位置（）{}
};
职位类别：公共职位{
整数计数；
公众：
StonePosition（const int count）{this->count=count；}
int getCount（）{返回此->计数；}
void setCount（int count）{this->count=count；}
朋友OsFrase& Cuths>代码类模板TB{{}{代码>可能会有帮助。C++不是那么灵活。你不能改变变量的类型。这就是为什么代码>模板/<代码>存在的原因，为什么你需要改变类型？看起来你只要在需要的时候就可以将代码>动态DistaCase< <代码> > <代码> >代码>（正如您对
getCrrPos
@lcs所做的那样，因为我需要更改类中StonePosition上变量Position的值StoneBoard@Nawy
dynamic\u cast
用于将父类型指针安全地强制转换为子类型指针。不要使用C样式强制转换。它们不安全。嗯，指针指向我也是一个问题。例如点er到一个类的位置不知道变量count的存在。
#include <iostream>
using namespace std;
class Position;
class StonePosition;

class Position {
public:
    Position() {}
};

class StonePosition : public Position {
    int count;
public:
    StonePosition(const int count) { this->count = count; }
    int getCount() { return this->count; }
    void setCount(int count) { this->count = count; }
    friend ostream& operator<<(ostream&, StonePosition);
};
template <typename TPos> class TBoard { 
protected:
    TPos* crrPos;
public:
    TBoard() { }
    TPos* getCrrPos() { return crrPos; }
    void setCrrPos(TPos* pos) { crrPos=pos; }
};
class Board {
protected:
    Position* crrPos;
public:
    Board() { }
    Position* getCrrPos() { return crrPos; }
    void setCrrPos(Position* pos) { crrPos=pos; }
};

class StoneBoard : public Board {
public:
    StoneBoard(const int &count) { this->crrPos=new StonePosition(count); } 
    Position* getCrrPos() { return crrPos; }
    void setCrrPos(Position* pos) { crrPos=pos; }
};

int main(){
    StoneBoard s(7);
    cout<<((StonePosition*)s.getCrrPos())->getCount();//<----right here
    system("pause");
    return 0;
}