Thread: Default Constructors

Circle::Circle doesn't need any parameters since you are defaulting it to zero, and you need to initilize radius in either an initializer list or inside the body of the function.

- SirCrono6

...also

Code:

private:
	float radius;

Circle::Circle(Raidus= 0);

Where is your member variable named Raidus? In addition, inside a class, you don't need to qualify variables or functions with the class name.

Code:

Circle::Circle()
	{
		cout << "Welcome to the constructor!\n ";
		cout << endl;
		cout << "The Radius is set to zero\n ";

Function definitions end with a closing brace.

I think by definition a default constructor has NO parameters, so it will always look like this:

Code:

ClassName()
{
     //do something
}

The only question is whether you have to define one or the compiler is going to supply one automatically. If you define ANY constructor, then the compiler won't supply a default constructor, and you need a default constructor to do this:

ClassName aThing;

in this line

Code:

Circle::Circle(Raidus= 0);

1. you need to specify the type of the paramter - more than likely, in this case, it should eb float
2. I assume Raidus is meant to be radius. you can't use the same name for parameter variables. you would need Circle::Circle(float r){ radius = r; }
3. You need to define AND protoype default constructors which take no parameters.
Circle(void) != Circle(float = 0); These are not the same functions.

Code:

class Circle
{
	private:
	float radius;
	float area;

	public:
	Circle(void);
         //no need for variable name in prototype
	Circle(float = 0);
};

Circle::Circle(void)
{
	cout << "Welcome to the REAL default constructor!\n ";
	cout << endl;
	cout << "The Radius is set to zero\n ";
         radius = 0;
}

//don't specify the default value here, only in the class prototype
Circle::Circle(float Radius) //i can use Radius because of case-sensitivity
{
	cout << "Welcome to the FAKE default constructor!\n ";
	cout << endl;
	cout << "The Radius is set to zero\n ";
         radius = Radius
}

This should compile as is, but once try to initialize an object, it will complain about this

Code:

Circle a();

but not this

Code:

float x = 3.145f;
Circle b(x);

however, i am unsure of the behaviour of this - i imagine this will complain to

Code:

Circle c;

can you guess why?

>>This should compile as is, but once try to initialize an object, it will complain about this

Although the compiler usually generates a default constructor/destructor as well as a copy constructor and assignment operator if you don't define one. See if this compiles:

Code:

class Test
{

};

int main()
{
Test A;
Test B(A);
Test C;
A=C;
}

that's not really what i was saying....with the code i posted above, you should get an ambiguous functions overload error.

seeing as Circle(void) and Circle(float = 0) can both be called the same way - Circle()

Here's my idea.

Code:

#include <iostream>
using namespace std;


class Circle
{        
    private:
        float radius;

    public:
        inline Circle() : radius(0.0){}//How about this?                
        void setRadius(float);
        float getRadius()
        {
            return radius;
        }
        float getArea();
};

//Class function definitions

void Circle::setRadius(float r)
{
    radius = r ;
}

float Circle::getArea()
{
    return 3.14159 * radius * radius;
}

int main()
{

    Circle Box;
    cout<<"Default Radius: ";
    cout<<Box.getRadius()<<endl;
    float CirRadius;
    cout << "Enter the radius of the circle " ;
    cout << endl;
    cin >> CirRadius;
    Box.setRadius(CirRadius);
    cout << "Your area is " << Box.getArea();
    cout << endl;

    getchar();
    getchar();
    return 0;
}

This would create a constructor plus a default constructor in one single step:

Code:

Circle::Circle(float Radius = 0.0f)
{
  this->Radius = Radius;
}

Originally Posted by Magos

This would create a constructor plus a default constructor in one single step:

Code:

Circle::Circle(float Radius = 0.0f)
{
  this->Radius = Radius;
}

by definition, a default constructor takes no parameters. that one does.

Originally Posted by Magos

Code:

Circle::Circle(float Radius = 0.0f)
{
  this->Radius = Radius;
}

Originally Posted by misplaced

by definition, a default constructor takes no parameters. that one does.

...nevertheless it serves as a default constructor, which you can test yourself:

Code:

#include <iostream>
using namespace std;

class Circle
{
public:
	float radius;

	Circle(float r = 0.0)
	{
		radius = r;
		cout<<"constructor called"<<endl;
	}

	
};

int main()
{
	Circle A(3.0);
	Circle B;  //what happens here??

	cout<<B.radius<<endl;

	return 0;
}

In fact, if you try to add the following default constructor to Circle:

Code:

Circle()
{
	radius = 0;
}

you will get the following error:

warning C4520: 'Circle' : multiple default constructors specified
error C2668: 'Circle::Circle' : ambiguous call to overloaded function

Originally Posted by SquirrelRJ

Next question, assuming everything is defined properly, would this added code work as an overload constructor?

It's not clear what your class looks like now, so it's a bit confusing, but this won't work:

Code:

Circle size(3.0);		//starting radius size of 3.0 added
float Radius;

size.Radius(Radius);

First of all, you have to use some imagination and not name every variable in your program Radius. The code fragment:

size.Radius

indicates that Radius is a member of the Circle class. But, then you also have a variable in main declared here:

float Radius;

So, my first piece of advice is: do NOT EVER name variables with identical names. Because of those identical variable names, it is not clear what you think you are doing with this statement:

size.Radius(Radius);

However, I'll assume you think you are trying to assign the value of a variable you called Radius to the Radius member of the size Circle. Another tip: capitalize your object names. However, there are a couple of things wrong with that statement:

1) Radius is a private member, so you cannot access it. Private members of a class can only be accessed by member functions of the class.

2)If the Radius were public, you still couldn't assign it a value doing this:

size.Radius(Radius)

The way you would assign the value is like this:

size.Radius = Radius;

You can do this:

Code:

float num(3.0);
cout<<num<<endl; //3

That's called "functional notation" for declaring initial values--but you must initialize the variable when it is declared. You cannot do this:

Code:

float num;
num(3.0);

The variable num has already been declared, and to the compiler, that looks like you are trying to call a function named num() and sending the argument 3.0 to the function. I suggest you don't use functional notation to initialize variables of simple types--I hardly ever see that done, and you will avoid these exact types of problems by not using it.