Passing a Temporary to a Constructor

try this way:

int main()
{
      foo f();
      Test t(f);
      t.dosomething(); // <--- error
}

you can do this instead which will work:

Test t = Test(foo());


Functions can have inner functions, that is why it is sometimes useful to place prototypes inside a function.

>>Functions can have inner functions, that is why it is sometimes useful to place prototypes inside a function.

I'm not sure what you mean here.  It sounds like you're talking about closures, which are not supported by C++.

What do you mean by inner function?

My Mistake. I thought you could have nested functions in C++, when in fact you can't.

http://www.velocityreviews.com/forums/t277810-nested-functions-in-c.html

there doesn't seem to be a problem with this code. check my snippet below. compiled and linked fine for me. which compiler are you using?

btw i dont think the compiler is dumb to think that it is a function declaration. It has info that Test is a class and you are calling the constructor with an object reference.
The lifetime of the foo object is controlled by the lifetime of object t. So there shouldn't be a problem as long as t is in scope.

What do you mean by a temporary and non temporary instance of foo? can you elaborate
there can be no case where an object needs to be created with no data members especially when you are passing another object to the constructor. your constructor does not seem meaningful.

class A
{
 
};
 
class B
{
public:
	B(const A& foo){}
	void dosum() {}
 
};
 
main()
{
	B obj(A());
	obj.dosum();
}

Select allOpen in new window

also check this which also works fine

#include <iostream.h>
 
class A
{
public:
	int as;
};
 
class B
{
	int y;
public:
	B(A& foo)
	{
     y=foo.as = 100;
	}
	void dosum() {
	 cout<<y;
	}
 
};
 
main()
{
	B obj(A());
	obj.dosum();
}

Select allOpen in new window

>> compiled and linked fine for me. which compiler are you using?

My question to you would be : what compiler are YOU using. It's clearly not following the standard. Your compiler should report that obj does not have a class type, and thus the line obj.dosum() is invalid.

trinitrotoluene, you seem to be using an antiquated compiler ;) <iostream.h> has been deprecated, and should not be used any more.

Infinity08,

>>Because it gives the programmer more freedom - he can add the function declaration in the local scope, so that >>it'll only be visible in that scope ... Other scopes can have their own declarations, even with the same name.

I'm not sure I understand this.  How is it at all useful to declare a function inside another function?  It doesn't seem to limit the scope of the function, or really do anything at all.  For example:

int foo()
{
      int bar(); // declare bar
      bar(); // call bar
}

int bar()
{
      cout << "Hello World!" << endl;
}

int main()
{
      foo();
      bar();
}

This code prints out "Hello World" twice.  Main has access to bar(), and so does foo(), even though bar() is declared in the scope of foo().  You can't actually *define* bar in foo, as if it were a closure or something, so what's the point of declaring bar in foo?

>>  It doesn't seem to limit the scope of the function, or really do anything at all.

No, it doesn't limit the scope of the function - it limits the scope of the function declaration. They are two different concepts (definition vs. declaration).


Consider the following code for example :

#include <iostream>
 
void test() {
  int fun();                // a local function declaration for the 'fun' function
  int value = fun() + 3;    // call the 'fun' function
  std::cout << value << std::endl;
}
 
void test2() {
  char *fun = "fun";        // a local C string named 'fun' - this works because of scope
  std::cout << fun << std::endl;
}
 
int fun() {                 // the 'fun' function definition
  return 5;
}
 
int main(void) {
  test();
  test2();
  return 0;
}

Select allOpen in new window

I see.  Still, C++ scoping rules would permit the code to compile anyway, even without the localized function definition.  If there is a global function fun(), and then a local scoped variable called fun, the local variable name will take precedence within its scope.  For example, the following code compiles fine:

int fun() {                 // the 'fun' function definition
  return 5;
}
 
void test() {
  int value = fun() + 3;    // call the 'fun' function
  std::cout << value << std::endl;
}
 
void test2() {
  char *fun = "fun";        // a local C string named 'fun' - this works because of scope
  std::cout << fun << std::endl;
}
 
int main(void) {
  test();
  test2();
  return 0;
}

Select allOpen in new window

Yes, but this was just a simple example. What if you're dealing with multiple files, and multiple 'fun' functions ?

Either way, it doesn't really matter, since a function declaration is a simple declaration, just like a variable declaration. Having it in a local scope is nothing special. A local function declaration is no more special than a local variable declaration. It's all about scope and locality.

You don't have to use local function declarations if you don't want to :)

infinity08 : I was using Visual Studio 6 and it built fine.

Do you have any good web link on this topic so that I can become more knowledgeable on it.

>> infinity08 : I was using Visual Studio 6 and it built fine.

That means that Visual Studio 6 is not following the standard :)


>> Do you have any good web link on this topic so that I can become more knowledgeable on it.

Read the C++ standard (ISO-IEC 14882:2003) ;)