标签: subclassing

快速健全性检查:是否可以使用仿函数对窗口进行子类化？我遇到了想要在win proc中获得一些数据的情况,但是GWLP_USERDATA已经被使用了.仿函数似乎是一个很好的选择,但我无法让它工作.

这是基础知识:

class MyWinProc { // Win Proc Functor
public:
    MyWinProc(ExternalClass* obj, HWND window) :
                obj(obj), window(window) {
                oldWinProc = SubclassWindow(window, this); // Apply Subclass
            }

    virtual ~MyWinProc() {
                SubclassWindow(window, oldWinProc); // Remove Subclass
            }

    LRESULT CALLBACK operator()(HWND, UINT, WPARAM, LPARAM) {
                switch( uMsg ) {
        case WM_MOUSEMOVE: {
            obj->onMouseMove(/*etc*/);
            break;
        }
                }
                return CallWindowProc(oldWinProc, hWnd, uMsg, wParam, lParam);
            }

private:
    ExternalClass* obj;
    HWND  window;
    WNDPROC oldWinProc;
};

好像很好,但当我在消息泵中点击DispatchMessage()时,我"访问违规写入位置0x00000000",显然不是一个好兆头.删除对上述代码的调用,生活再次开心.:(所以这甚至可能,或者我完全以错误的方式去做？

我需要从System.Type继承固定点数类.

class FixedPoint : Type
{
    public bool Signed { get; set; }
    public int Width { get; set; }
    public int IntegerWidth { get; set; }
    public FixedPoint(Boolean signed = false, int width = 16, int integerWidth = 8)
    {
        Signed = signed;
        Width = width;
        IntegerWidth = integerWidth;
    }
}

当我尝试编译此代码时,我收到错误消息,说我需要实现方法,因为Type是抽象类.

userdef.cs(3,7): error CS0534: 'FixedPoint' does not implement inherited abstract member 'System.Type.GUID.get'
userdef.cs(3,7): error CS0534: 'FixedPoint' does not implement inherited abstract member 'System.Type.Namespace.get'
c:\Windows\Microsoft.NET\Framework\v4.0.30319\mscorlib.dll: (Location of symbol related …

我正在用Qt创建一个应用程序.我正在使用带有QGraphicsScene的QGraphicsView.我正在对QGraphicsView进行子类化,因为我需要添加自定义鼠标事件功能.我的问题是,当我重新实现鼠标事件功能时,原始的QGraphicsView功能不起作用.

即我重新实现了一些鼠标按下和释放事件,现在我无法拖动QGraphicsScene,即使我有

this->setDragMode(QGraphicsView::ScrollHandDrag);

希望我的问题很清楚,如果不是,请让我知道什么是不清楚的.

正如标题所描述的那样,我希望为每个UIViewController和每个子类(如UITableViewController)添加自定义属性.我的第一个想法是创建一个类别,但后来我意识到不能在其中添加ivars,所以我无法合成属性.如果我只是子类UIViewController并在那里添加东西,它不会影响其他子类.

基本上我的目的是为我的'UINavigationController'子类添加一个自定义工具栏(不,我不能出于各种原因使用默认值).它需要询问每个viewController是否需要工具栏,以及 - 在这种情况下 - 是否为toolbarItems数组.这有点像我相信UIToolbar的工作原理吗？

你会怎么做？

我有一个设置,我有一个视图类型的层次结构,具有等效的模型类型层次结构.设置如下:

节点模型/数据:

@interface GenericNode : NSObject
//blah blah blah
@end
@interface ShapeNode : GenericNode
//more blah
@end

nodeViews,它将始终接收一个等效类型的节点作为其模型:

@interface GenericNodeView : UIView
@property (nonatomic, strong) GenericNode * model;
@end
@interface ShapeNodeView : GenericNodeView
@end

但是,这里的问题是它的类型model总是保留为抽象超类,迫使我每次想要访问子类属性的方法时都要强制转换它.

有没有办法重铸类属性,exampleShapeNodeView.model总是返回一个实例ShapeNode等等？

我尝试过自定义访问器方法,如

@interface GenericNodeView : UIView
@property (nonatomic, strong) GenericNode * model;
-(GenericNode *)myModel;
@end
@interface ShapeNodeView : GenericNodeView
-(ShapeNode *)myModel;
@end

//in genericNodeView implementation
-(GenericNode *)myModel{
  return (GenericNode *) self.model;
}

//in shapeNodeView implementation
-(ShapeNode *)myModel{
  return (ShapeNode …

有Car一个公共方法的类

public Car myself() {
  return this;
}

有一个子类Ferrari,以及一个foo包含Ferrari对象的变量.

最后,

Ferrari bar = foo.myself();

这会警告你,因为该方法myself()返回一个Car对象,而不是预期的对象Ferrari.

注意:我知道这个例子很愚蠢,因为你只是这么做bar = foo.这只是一个例子.

解决方案:

• 覆盖myself()方法Ferrari.
• 在分配时将Car对象强制转换为Ferrari对象bar.

两种解决方案都有效,我对此感到满意.但是,当你有几个子类时,第一个是不可取的Car.我觉得一遍又一遍地覆盖一种方法会破坏继承它的意义.接下来,关于第二种解决方案,铸造并不漂亮.感觉很愚蠢 - 如果我的变量是类型的Ferrari,那么Java是否应该能够在没有警告我的情况下隐式地转换它？毕竟,Java必须知道返回的对象可以被转换为Ferrari,不是吗？

还有另一种解决方法吗？只是出于好奇 - 我可以忍受铸造的东西,告诉Java应该是什么东西......

我正在阅读一本Java书,并且这次再次思考这一段实际意味着什么:

接口旨在支持运行时的动态方法解析.通常,为了从一个类调用方法到另一个类,两个类都需要在编译时出现,因此Java编译器可以检查以确保方法签名是兼容的.这个要求本身就是一个静态和不可扩展的分类环境.在这样的系统中,不可避免地会在类层次结构中将功能提升得越来越高,以便机制可用于越来越多的子类.接口旨在避免此问题.它们将方法或方法集的定义与继承层次结构断开连接.由于接口与类的层次结构不同,因此在类层次结构方面不相关的类可能实现相同的接口.这是实现接口真正功能的地方.

第一个问题:作者的意思是什么from one class to another？他是否意味着这些类在层次结构方面是相关的？我的意思是,将子类对象引用分配给它的超类类型变量然后调用方法？

第二个问题:作者再次提出什么意思This requirement by itself makes for a static and nonextensible classing environment？我不明白其makes for含义(英语不是我的主要语言)以及为什么环境被称为静态和不可扩展.

第三个问题:他的意思是什么functionality gets pushed up higher and higher？为什么它会越来越高？什么功能？还有mechanisms will be available to more and more subclasses.什么机制？方法？

第四个问题:Interfaces are designed to avoid this problem.什么问题？？？

我知道答案必须明显,但我不知道.也许主要是因为我没有看到一些神奇的英语短语.请帮助我理解这一段的内容.

我只是揣摩相比,子类类别的上攻......我明白他们是如何实现的,但我看到就在此刻唯一的好处是,它可以节省你重构你的整个代码,如果你想延长在后期使用的课程,通常不应该通过良好的计划来实现.否则,它需要大约相同的时间来实现作为子类,它并没有真正带来不同的功能.因此,对于我对子类与类别的了解,我没有看到使用类别的原因.有人可以洗头,解释存在类别的原因吗？我会非常感激:)

为什么这个有效的C++不是？:

enum foo : unsigned { first_foo, second_foo };
enum bar : foo { best_foo = first_foo };

GCC 5.4.0说:

/tmp/a.cpp:3:16: error: underlying type ‘foo’ of ‘bar’ must be an integral type
     enum bar : foo { best_foo = first_foo };

我可以理解为什么我会得到这个错误,如果foo是一个float,或一些结构,或什么不是.但就语义,类型安全等而言,这似乎是完全合法的.我缺少什么？

以下玩具示例有点奇怪,但它显示问题就像我可以说的那样.

首先,没有问题的部分:

class TupleWrapper(tuple):
    def __new__(cls, ignored):
        return super(TupleWrapper, cls).__new__(cls, [1, 2, 3])

该类TupleWrapper采用任意方式返回类似于常量的类似元组的对象(1, 2, 3).例如:

>>> TupleWrapper('foo')
(1, 2, 3)
>>> TupleWrapper(8)
(1, 2, 3)

到现在为止还挺好.

现在,考虑这个类:

class ListWrapper(list):
    def __new__(cls, ignored):
        return super(ListWrapper, cls).__new__(cls, [1, 2, 3])

TupleWrapper除了它的子类list而不是它之外,它是相同的tuple.因此,我期待以下

>>> ListWrapper('foo')
[1, 2, 3]
>>> ListWrapper(8)
[1, 2, 3]

事实上,我得到的是

>>> ListWrapper('foo')
['f', 'o', 'o']
>>> ListWrapper(8)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' …