class car {
int speed;
double position;
public:
car(int v,double d);
int getspeed();
};
int car::getspeed() {
return speed;
}
car::car(int s, double x){
speed=s;
position=x;
}
Even though i specified different variables for car(int s,v), why does it work? i though it should give me a compile time error?
this code:which var it uses?
class car {
int speed;
double position;
public:
car(int speed,double time);
int getspeed();
};
int car::getspeed() {
return speed;
}
car::car(int speed, double position){
speed=speed;
position=position;
}
I think the global variable might be used, or is it something you can't say certain about
In this function definition, it does nothing with the class member car::speed, and car::position, because you declared the local int speed and double position in the function parameter list, they hide the class member variables. To do it properly, you need explicitly say so:
This constructor doesn't work
because it assigns the parameters to themselves.
This version does work because of the slightly odd scoping rules of a class
In the second case, I believe the closest scope variable is used. So, first it checks the local function scope, and finds both speed and position, so the search stops there. In effect, the second constructor isn't actually assigning obje
The names of parameteres are not important. Types of parameteres create the signature. The signature is the same, so there is no compile error.
In second example speed in constructor will shadow speed atribute. Therefore you will assign parameter value to parameter variable. You need:
this->speed = speed;
And this is not guesswork ;-).
In your code:
you're just assigning each variable's value to itself. You can however do:
in addition to explicitly accessing the member variables via
this->
The compiler doesn't care about your variable names in the method declaration, just the signature, which is
car::car(int,double)
for both your constructor declaration and your implementation, so it knows to match these up when linking. This is possible because you cannot have two methods in the class with the same signature. (You can do this with subclasses, but the result is an override).