Printable View
Hello everyone,
I have tried compiler allows to change const property of an overloaded method. Here is my proof of concept code.
My question,
1. is it good code or good practice?
2. It yse in (1), are there any practical usage of this type of "overloading"?
Code:class Base {
public:
const int foo() {return 200;};
};
class Derived : public Base {
public:
int foo() {return 100;};
};
int main()
{
Base b;
Derived d;
int rtn = b.foo();
rtn = d.foo();
return 0;
}
thanks in advance,
George
Your concept code doesn't tell me much.
An integer called rtn is declared, and assigned 200 from b.foo(). Then it is assigned 100 from d.foo().
The return type of foo (int or const int) has no relevance in this code: the return value is assigned to a simple non-const int and you can do anything you like with it. The code would compile the same if you swapped the calls to d.foo() and b.foo().
Hi anon,
My bad example. I mean overriding, not overloading. I have tested we can change the parameter type from const to non-const (and vice versa) in base/derived class and it still works.
1. is it good code or good practice?
2. It yse in (1), are there any practical usage of this type of "overriding"?
Code:class Base {
public:
const int foo () {return 200;}
const int goo (const int input) {return 200;}
};
class Derived : public Base {
public:
int foo() {return 100;}
int goo (int input) {return 200;}
};
int main()
{
Base b;
Derived d;
int rtn = b.foo();
rtn = d.foo();
return 0;
}
regards,
George
Quote:
Originally Posted by anon
Nothing has changed. The constness of primitive temporaries is irrelevant.
Nor are you overriding anything, because the functions of the base class aren't virtual.
But for what it's worth, with the exception of return type covariance, having overriding functions return a different type from the base versions is not only very, very bad practice, but also largely disallowed when actually overriding.
Thanks CornedBee,
primitive temporaries means temporary variable for POD types?Quote:
Originally Posted by CornedBee
What do you mean covariance?Quote:
Originally Posted by CornedBee
regards,
George
>> primitive temporaries means temporary variable for POD types?
As far as I can tell.
>> What do you mean covariance?
Covariant return types are defined here in this discussion of the virtual constructor idiom. In a nutshell, the feature, when supported, allows a difference in return type for a function that you were supposed to implement for an instance of some (abstract) class. This is largely supported out of respect for type strictness, I believe.
Thanks citizen,
It is good article and I take some time to study. Cool!!Quote:
Originally Posted by citizen
Sorry I am not English speaker, and I do not know what the word "CoVariant" means here. I have looked up dictionary and only find it is a math term. :-)
It is appreciated if you could say in some other words about what CoVariant mean?
have a good weekend,
George
It's "covariant", not "CoVariant". If there was any need for weird capitalization, I'd have used it in my original post.
Covariance is a term specific to type theory. As such, the likelihood that you'd find it in a dictionary is rather slim. The idea is that as one property varies, another varies along with it - it "co-varies", thus showing covariance.
In return type covariance, the primary varying item is the class that contains the method, and the secondary varying item is the return type of the method. As the primary varying item descends a class hierarchy, the secondary does, too. Usually, it's the same class hierarchy, but it doesn't have to be.
The opposite of covariance is contravariance. Like covariance, contravariance is about two variables changing together, but the secondary variable changes in a way that is contrary to the primary variable. In type theory, the most important instance is argument contravariance. It's best illustrated as a snippet of code:
Note that, as the implementation class descends in the bar hierarchy, the argument of the method ascends. That's contravariance.Code:class foo_base {};
class foo_derived : public foo_base {};
class bar_base
{
public:
virtual void method(foo_derived&) = 0;
};
class bar_derived
{
public:
void method(foo_base&);
};
Don't be fooled by the C++ syntax of the snippet. Contravariance is not supported by C++. The likely reason is that the interactions with overloading and type-safe linking were too complicated.
Thanks CornedBee,
So, covariance in section [20.8] What is a "virtual constructor"? of http://www.parashift.com/c++-faq-lit....html#faq-20.8Quote:
Originally Posted by CornedBee
means, in the base class create/clone has return type Shape* in class Shape, but in derived class Circle, create/clone has return return type Circle*, right? So, (class and return type) covariant -- cochange? :-)
regards,
George
Yes, it's one instance of covariance.
Thanks CornedBee!
This is what you mentioned before,
--------------------
But for what it's worth, with the exception of return type covariance, having overriding functions return a different type from the base versions is not only very, very bad practice, but also largely disallowed when actually overriding.
--------------------
I have made some test on this statement,
Compile error message,Code:class Base {
public:
virtual int foo() {};
};
class Derived : public Base {
public:
virtual double foo() {};
};
1>d:\visual studio 2008\projects\test_overriding1\test_overriding1\ma in.cpp(9) : error C2555: 'Derived::foo': overriding virtual function return type differs and is not covariant from 'Base::foo'
My question is, for the concept of covariant, when we change from base to derived (this is one aspect of variant, and to make it "co"-variant, we could also change something at the same time in derived class to make it co-variant -- having two variants?), how could we change something in foo method in derived class to make it work and have the covariant pattern?
regards,
George
Quote:
Originally Posted by CornedBee
You could use templates this way:
Code:template <typename T>
class base {
base() { }
virtual T foo() = 0;
};
class derived : base<double> {
derived() { }
double foo() { return 0.0 }
};
That's not formally true.Quote:
Originally Posted by CornedBee
Covariance is actually a mathematical term, and it is a measure of correlation between two random variables. The covariance of two random variables X and Y, Cov(X,Y), is defined aswhereCode:E{(X-E{X})(Y-E{Y})}
is the expected value of A (i.e. the statistical mean).Code:E{A}
Covariance in type theory, as you describe it, is actually a special case of the mathematical concept in which X and Y have discrete values (eg in return type covariance, X is the set of types of the object containing the method and Y is the set of return types of the method). Contracovariance simply means that the covariance Cov(X,Y) has a negative value.
I very much doubt that any type theoretician will agree that type covariance is really founded in stochastic covariance. The two concepts have similarities - thus the same name - but there is simply no practical value in treating one as the derivate of the other.
Hi CornedBee,
I take time to re-study your post in #8. I found I re-learned new stuff. Cool! Three more comments,
1. Beyond the pattern of decend/ascend in return type/class hierarchy as we pointed out, is it the only pattern of covariance? Are there any else patterns in C++ which could be called covariance?
2. Interested in Contravariance sample, does it have practical usage scenario?
3. about your comments,
"As the primary varying item descends a class hierarchy, the secondary does, too"
primary varying item is the class hierarchy base/derived class, and the secondary (varying item) is the return type (in derived class, using derived class type pointer, but in base class, using base class type pointer?)?
Quote:
Originally Posted by CornedBee
Hi grumpy,
Could you let me know how you get nagetive value in the case of contracovariance please? How do you assign value X and Y?
Quote:
Originally Posted by grumpy
regards,
George
CornedBee: the underpinning of type theory is actually category theory, which is a branch of discrete mathematics. There is very little in mathematics that can't be found to have practical value (although "practical" does not mean the same thing as "understandable to everyone") ....
George: Let's say we have a Base class with a virtual method that returns a pointer to Base, and two Derived classes Derived1 and Derived2 that override that method. So the return value from Base::method() is a Base*, return value from Derived1::method() is a Derived1*, and Derived2::method() returns a Derived2.
If X is the set of classes [Base, Derived1, Derived2] with some ordering so it is considered that Base < Derived1 < Derived2. A simple encoding would be to represent them as distinct integers. Let's say [1,2,3].
Similarly Y denotes the set of return types from the method, namely [Base*, Derived1*, Derived2*] which may be encoded as a set of integers too. Let's say [4,5,6]. This is actually a covariant example (Base->Base*, Derived1->Derived1*, Derived2->Derived2*). The set of pairs (X,Y) are [(1,4), (2,5), (3,6)]. Since the mean of X is 2 and mean of Y is 5, the covariance may be computed as Cov(X,Y) = ((-1)*(-1) + 0*0 + 1*1)/3 = 2/3 (a positive value).
One type of contracovariance (which, as I think CornedBee said earlier, is not possible in C++) would be to reverse the relationship between return value and the containing class. For example, if the return value of Base::method() is Derived2*, Derived1::method returns Derived1, and Derived2::method() returns Base. This would map to a set of pairs (X,Y) which is [(1,6), (2,5), (3,4)] from which Cov(X,Y) = -2/3.
The key in the representation is picking a distinct ordering relationship for types, and ensuring a unique value for each distinct type. There is also a reliance on invariance relationships. For example, in the above, the relationship Base < Derived1 < Derived2 invariably implies the relationship Base* < Derived1* < Derived2*
Nothing else in C++ is called covariance.Quote:
Originally Posted by George2
Since it isn't supported in any language I know, I've never given it thought.Quote:
2. Interested in Contravariance sample, does it have practical usage scenario?
Yes. Note that the hierarchy that varies in the return type doesn't have to be the same as the hierarchy that contains the method, as shown in by foo/bar sample.Quote:
primary varying item is the class hierarchy base/derived class, and the secondary (varying item) is the return type (in derived class, using derived class type pointer, but in base class, using base class type pointer?)?