difference btw two type of declaration

[kunalnandi]

Class Base
{

};

main()
{
  Base b;        // First type
  Base b();      // Second type
}

What is the difference in above two type of declaration?

[shadow123]

There's no difference. On creating the objects you are calling the default constructor.

Edit: That's wrong -.-*

[codekiddy]

hi kunalnandi,

First type:
(creating object which will be initialized with default constructor)


Second type:
(declaration of an function which takes no argumets and returns an object of class "Base")
#note that declaration not definition!

keyword class must begin with small 'c'
your code:

Class Base //REPLACE WITH class
{

};

EDIT:
main function must have function type and return value as all other functions do...
your code:

main()  //ADD int
{
  Base b;   
  Base b();    
//ADD return 0;
}

[shadow123]

Hello codekiddy,

but the second type is an instantiation, too (at least in this context).

Edit: That's wrong -.-*

[codekiddy]

hi shadow123,

yes you may be right by saying context, but in context of the code which mr. threadstarter provided you're not.

because an empty parentheses initializer is allowed in other contexts e.g. in a new expression or constructing a value-initialized temporary.

for example:

int main() {
   Base* a = new Base();
   Base b = Base();
   return 0;
}

cheers mate!

[Karajic]

hi

first one is the declaration of an object by default constructor. (google it).

second is the declaration of the object with explicit constructor. In this case you usually pass a value right away which becomes a value of the element of the class;

For ex:

Class Base
{
public:
Base();
Base(int x);

private:
int number;
};

Base::Base(){
number = 0;
}

Base::Base(int  x){
number = x;
}

main()
{
  Base b;        // First type. in this case NUMBER is equal to 0
  Base b(60);      // Second type. in this case NUMBER is equal to 60 but you have to pass a value to the object when you create it.
}

Something like that if I got you question correctly.

[1vRz3TCk]

Class Base
{

};

main()
{
  Base b;        // First type
  Base b();      // Second type
}

What is the difference in above two type of declaration?

The first declares an object called b that is of type Base.
The second declares a function called b that returns a Base.

See: http://www.parashift.com/c++-faq-lite/ctors.html#faq-10.2

[codekiddy]

Something like that if I got you question correctly.

hi Karajic, don't get me wrong but /
I think the question was:

 Base b;        // First type
 Base b();      // Second type 

and not:

Base b;          // First type
Base b(60);      // Second type. 

The question was using default constructor, not overloaded(user defined) constructor.

kind regards!

[codekiddy]

@CodeMonkey

The first declares an object called b that is of type Base.
The second declares a function called b that returns a Base.

Respect, but the same answer has already been given ;)

[1vRz3TCk]

Respect, but the same answer has already been given ;)

I know but it was disputed. A second answer with corroborating information only goes to reenforce the correct answer.

[shadow123]

Ooops, I've compiled/tested the wrong example :(

Sure, codekiddy is right!

[kunalnandi]

Thank you everyone for your answers.

 Base b;        // First type
 Base b();      // Second type 

What I understand is there can be two type of context in these two type of declaration

First Context:

If you want to declare a object of class Base there can be either on declaration at a time, because both of them are same kind of declaration.

Second Context:

Create a object of class Base and if you want to declare a function which returns object of Base class then you must use different name it can't be Base b();, if you don't do so compiler will throw error that you have done a redeclaration of object b

[codekiddy]

hi,

object can be created in few different ways:

int a; (object created on the stack and it's initial value is 0)
int* a = new int; (object created dinamicaly and it's initial value is unknown)

Base a = Base(); (here right operand is temporal object and it's initial value(of it's members) is 0)
Base* b = new Base; (here b is initialize with value of zerro) (it's members!)
base* c = new Base(); (here c object (not pointer ) is initilized with zerro cos default constructor has been cled)

Base x(); (THIS IS WRONG AND HAS NO EFECT) just a sily declaration of some function

of course is has efect if you realy have such function defined(not declared)

as you see the is no context but just a simple rules about declaration and mermory alocation.

cheers!

[kunalnandi]

Thanks!!