parameter initialization in constructor

[mzimmers]

I have a class:

class FlipFlopReg32
{
		int32_t		resetValue;
		int32_t		qCurrent;
		int32_t		qNext;
public:
		FlipFlopReg32(int32_t rv = 0,         // default constructor
			   int32_t c = 0,
			   int32_t n = 0);

What I'd like to do, is if the 2nd and/or 3rd argument is left off the call to the constructor, qCurrent and/or qNext would take the value of resetValue.

Anyone know of a way to code this?

Thanks.

[LB]

That's not the default constructor as the comment says.

To do what you want, you just need to overload the constructor with a version that only takes rv:

FlipFlopReg32();//Default
FlipFlopReg32(int32_t rv, int32_t c, int32_t n); //Version 1
FlipFlopReg32(int32_t rv); //Version 2 

FlipFlopReg32::FlipFlopReg32() : resetValue(0), qCurrent(0), qNext(0)
{
    //any other initialization
}

FlipFlopReg32::FlipFlopReg32(int32_t rv, int32_t c, int32_t n) : resetValue(rv), qCurrent(c), qNext(n)
{
    //any other initialization
}

FlipFlopReg32::FlipFlopReg32(int32_t rv) : resetValue(rv), qCurrent(rv), qNext(rv)
{
    //any other initialization
}

[mzimmers]

Oh...very good. Thanks for the quick reply.

Why isn't what I posted the default constructor? Every parameter has a default value...isn't that sufficient criteria?

[LB]

The default constructor is the one that takes no parameters. While your function can have all its parameters omitted to look like it is the default constructor, your code actually doesn't have a default constructor.

[Cubbi]

@ L B It actually *is* the default constructor by definition

§12.1[class.ctor]/5

A default constructor for a class X is a constructor of class X that can be called without an argument

[mzimmers]

OK...I thought I remember my teacher saying otherwise, but I'll take your word for it. I think, though, that with a constructor like this, I don't really need a true default c'tor, do I?

[LB]

No, you don't need a true default constructor - I just included it to show what I meant. The second constructor in my example can have rv = 0 by default.

@Cubbi: When using functions whose arguments have default values, are you sure the values are not implicitly passed? In that case the constructor is receiving arguments that aren't actually visible in the calling code.

[Cubbi]

@L B Classification of constructors has nothing to do with passing values to functions. It has to do with whether the expression X() is well-formed.

[LB]

Calling without can argument is different from writing code that does not pass an argument.
Actually, I guess you're right; the this pointer is passed implicitly so even the default constructor is passed an argument...

[mzimmers]

I just tried implementing the above solution as follows:

		FlipFlopReg32(int32_t rv = 0,         // default constructor
			   int32_t c = 0,
			   int32_t n = 0);
		FlipFlopReg32(int32_t rv);			// single parameter constructor 

And on this line of code, the compiler is telling me that the calls to the *copy* constructor are ambiguous.

Nco::Nco(int32_t rv) : regSin(rv), regCos(rv)

(regSin and regCos are FlipFlopReg32 objects.)

Can someone explain what is going on?

[Gaminic]

If you call FlipFlopReg32(myInt32_t), you might mean FlipFlopReg32(myInt32_t) or FlipFlopReg32(myInt32_t, 0, 0). The compiler has no way of knowing.

[mzimmers]

OK, so what's the answer, then. Do I have to remove the defaults from my first constructor?