标签: upcasting

我试图改造一个对象.但是在运行时,对象类仍然是派生类.

Derived drv = new Derived();

Base base = (Base) drv;

System.out.println("Class : " + base.getClass()); 

//prints -> Class : class packagename.Derived

那么为什么类属性没有改变？

在我正在编写的程序中,我有一个类RestrictedUser和类User派生RestrictedUser.自我试图通过强制转换来隐藏用户特定的方法RestrictedUser但是当我进行转换时,User方法仍然可用.当我运行调试器时,变量的类型也会出现User.

RestrictedUser restricted = regularUser;

在Java中进行强制转换是否隐藏了子类方法和字段,或者我做错了什么？有解决方法吗？

谢谢

我有一个普通的旧CRPT(请不要因访问限制而分心 - 问题与他们无关):

 template<class Derived>
 class Base {
     void MethodToOverride()
     {
        // generic stuff here
     }
     void ProblematicMethod()
     {
         static_cast<Derived*>(this)->MethodToOverride();
     } 
 };

像往常一样打算像这样使用:

 class ConcreteDerived : public Base<ConcreteDerived> {
     void MethodToOverride()
     {
        //custom stuff here, then maybe
        Base::MethodToOverride();
     }
 };

现在static_cast困扰我了.我需要一个向下投射(不是向上投射),所以我必须使用一个明确的演员.在所有合理的情况下,强制转换都是有效的,因为当前对象确实是派生类.

但是如果我以某种方式改变层次结构并且演员现在变得无效呢？

我可以以某种方式强制执行编译时检查,在这种情况下显式向下转换有效吗？

在Java中,按位运算会导致类型转换为整数,并且还会导致符号扩展.例如,预期如下:

byte b = -1;
System.out.println(b >> 1);//-1

在Java中,字符以UTF-16编码,每个单元用2个字节表示.

char c = 0xFFFF; //I assume now the sign bit is 1.
System.out.println(c >> 1);//32767 ???? WHY

我期待-1而不是32767.为什么在应用按位操作之前,在类型转换期间标志没有延长？有任何想法吗？

各位晚上好.
代码片段将值千言万语:

// Storage suitable for any of the listed instances
alignas(MaxAlign<Base, Derived1, Derived2>::value)
char storage[MaxSize<Base, Derived1, Derived2>::value];

// Instanciate one of the derived classes using placement new
new (storage) Derived2(3.14);


// Later...

// Recover a pointer to the base class
Base &ref = *reinterpret_cast<Base*> (storage);

// Use its (virtual) functions
ref.print();

// Destroy it when we're done.
ref.~Base();

如您所见,我只想通过其基类访问实例,而不实际存储基类指针.请注意,在第二部分中,Derived2类型信息将丢失,因此我只剩下storage并保证一个派生实例在其中.

由于placement new永远不会调整目标指针,因此归结为使用reinterpret_castupcast到基类.现在我知道这很危险,因为static_cast在某些情况下更适合调整指针.[1]

实际上,它会触发未定义的行为.你会在Coliru(g ++ 4.9.0)上找到完整的代码,它会在运行时迅速崩溃.同时在我的电脑上(g ++ 4.8.2),一切都很好.请注意,在g ++ …

考虑以下代码:

class MyClass
{
}

class MyClass2 : MyClass
{
}

private void Foo(MyClass cl)
{
    //cl is actually MyClass2 instance
    TestGeneric(cl);
}

private void TestGeneric<T>(T val)
{
     //do smth
}

在调用Foo()之后,TestGeneric中的T是MyClass,而不是MyClass2.如何将val视为MyClass2实例？提前致谢.

Upd:我实际上并不知道该对象是使用MyClass2 ctor 创建的,而是可以通过调用val.GetType()来推断它,所以简单的MyClass2将不起作用

我有在我从数据库中获取数据的情况下,我想它上溯造型到ArrayList of objects,然后其向下转换到不同的自定义的ArrayList即List<User>,List<Groups>等等.

我的问题是向上转换为对象,然后向下转换为ArrayList,这将是成本,是高效还是良好的做法.

EDITED

List<User>, List<Groups>我不想获取数据等,而是根据我的需要获取数据ArrayList<objetcs>,我会将数据转发给ArrayList<User>, ArrayList<Groups>以后.

鉴于以下代码,我从Shape继承了一个Circle:

class Shape
{
    void Draw();
}

class Circle : Shape
{
}

void Main(string[] args)
{
    Shape s = new Shape();
    Shape s2 = new Shape();
    Circle c = new Circle();

    List<Shape> ShapeList = new List<Shape>();

    ShapeList.Add(s);
    ShapeList.Add(s2);
    ShapeList.Add(c);
}

怎么可以c加入ShapeList？

当java可以隐式地进行转换时,为什么不隐式地进行转换？请用一些简单的例子来解释一下？

假设我有三个类:A(母亲,抽象),B和C,A的孩子.

所以B和C继承自A(公共继承).我有一个指向A的指针列表,我用B或C指针填充.

问题是:在进行铸造/转换时哪个是首选的样式？

class A {};
class B : public A {};
class C : public A {};

B* objB = new B();
C* objC = new C();

std::list<A*> myList;
// Option A: static cast conversion
myList.push_back(static_cast<A*> (objB));
myList.push_back(static_cast<A*> (objC));

// Option B: implicit conversion
myList.push_back(objB);
myList.push_back(objC);

// Option C: C-style conversion (I understand that this is evil and must be avoided)
myList.push_back((A*) objB);
myList.push_back((A*) objC);

那么,就清晰度(代码风格)而言,在安全性方面,哪一个更好？我知道static_cast更容易搜索,但在这种情况下,隐式转换应该足够了.