covariance

using namespace boost; class A {}; class B : public A {}; class X { virtual shared_ptr<A> foo(); }; class Y : public X { virtual shared_ptr<B> foo(); }; The return types aren't covariant (nor are they, therefore, legal), but they would be if I was using raw pointers instead. What's the commonly accepted idiom to work around this, if there is one? I think that a solution is fundamentally impossible because covariance depends on pointer arithmetic which is incompatible with smart pointers. When Y::foo returns shared_ptr<B> to a dynamic caller, it must be cast to shared_ptr<A> before use. In your

I have a quite complex class hierarchy in which the classes are cross-like depending on each other: There are two abstract classes A and C containing a method that returns an instance of C and A, respectively. In their inherited classes I want to use a co-variant type, which is in this case a problem since I don't know a way to forward-declare the inheritance relation ship. I obtain a "test.cpp:22: error: invalid covariant return type for ‘virtual D* B::outC()’"-error since the compiler does not know that D is a subclass of C. class C; class A { public: virtual C* outC() = 0; }; class C {

This has been asked several different ways already - but I haven't found my answer yet. Can someone clarify a few things for me please. Using : Delphi XE2 I have quite a big BaseObject that I use for almost everything. Along with it I have a Generic list - BaseList. Delarations go like this : TBaseObject = class ... a lot of properties and methods ... end; TBaseList<T: TBaseObject> = class(TObjectList<T>) ... some properties and methods ... end; I have recently tried to change the TBaseList declaration from a very old TStringList using Objects[] property... to this never more versatile

It is possible in C# to add variance annotation to type parameter, constrained to be value type: interface IFoo<in T> where T : struct { void Boo(T x); } Why is this allowed by compiler if variance annotation makes completely no sense in a such situation? Why this is allowed by compiler since variance annotation make completely no sense in a such situation? It's allowed by the compiler because I never even considered that someone might try to do that when I added the variance rules to the C# 4.0 compiler. Compiler warnings and errors are features , and in order for a feature to be implemented,

I am trying to figure out how to calculate covariance with the Python Numpy function cov. When I pass it two one-dimentional arrays, I get back a 2x2 matrix of results. I don't know what to do with that. I'm not great at statistics, but I believe covariance in such a situation should be a single number. This is what I am looking for. I wrote my own: def cov(a, b): if len(a) != len(b): return a_mean = np.mean(a) b_mean = np.mean(b) sum = 0 for i in range(0, len(a)): sum += ((a[i] - a_mean) * (b[i] - b_mean)) return sum/(len(a)-1) That works, but I figure the Numpy version is much more efficient

I have a private readonly list of LinkLabel s ( IList<LinkLabel> ). I later add LinkLabel s to this list and add those labels to a FlowLayoutPanel like follows: foreach(var s in strings) { _list.Add(new LinkLabel{Text=s}); } flPanel.Controls.AddRange(_list.ToArray()); Resharper shows me a warning: Co-variant array conversion from LinkLabel[] to Control[] can cause run-time exception on write operation . Please help me to figure out: What does this means? This is a user control and will not be accessed by multiple objects to setup labels, so keeping code as such will not affect it. What it