auto_ptr compile error

Hello everyone,


Two questions,

1.

The following compiler error from the following code segment, is because delete statement from destructor of auto_ptr requires the declaration of destructor of wrapped object?

Code:

---

1>main.cpp
1>d:\visual studio 2008\projects\test_autoptr2\test_autoptr2\main.cpp(10) : error C2512: 'Foo' : no appropriate default constructor available

#include <memory>
#include <iostream>

using namespace std;

class Foo;

void func()
{
        auto_ptr<Foo> pf (new Foo());

        cout << "I am here. " << endl;

        return;
}

int main()
{
        func();

        return 0;
}

class Foo {
};

---

2.

If yes, how to define a destructor outside of the body of class declaration? I defined in this way, but compile can not pass.

Code:

---

Foo::~Foo()
{

}

---

thanks in advance,
George

You discovered that smart pointers place certain requirements on the pointed-to object. An auto_ptr cannot use an incomplete type. It is explicitly forbidden in the standard. Even though you define the type further down, it has to be complete at the point of template instantiation.

And it's crazy to think you can just define a Foo::~Foo() without also changing the class declaration itself. The solution isn't to write a destructor, it's to use a complete type instead of an incomplete one.

Thanks brewbuck,


1.

Quote:

---

Originally Posted by brewbuck

You discovered that smart pointers place certain requirements on the pointed-to object. An auto_ptr cannot use an incomplete type. It is explicitly forbidden in the standard. Even though you define the type further down, it has to be complete at the point of template instantiation.

---

You mean before using auto_ptr, the whole declaration of class should be before it?

2.

Quote:

---

Originally Posted by brewbuck

And it's crazy to think you can just define a Foo::~Foo() without also changing the class declaration itself. The solution isn't to write a destructor, it's to use a complete type instead of an incomplete one.

---

How to fix? I have tried in this way, but still can not compile.

Code:

---

#include <memory>
#include <iostream>

using namespace std;

class Foo;

Foo::~Foo()
{
}

void func()
{
        auto_ptr<Foo> pf (new Foo());

        cout << "I am here. " << endl;

        return;
}

int main()
{
        func();

        return 0;
}

class Foo {
public:
~Foo()
{
}

};

---

regards,
George

It still won't compile because you still have not defined the type before the auto_ptr is declared.

This code needs to come before the auto_ptr instantiation:

Code:

---

class Foo {
};

---

Thanks King,


I think put only declaration of class, including constructor and destructor declaration is enough, right?

Quote:

---

Originally Posted by King Mir

This code needs to come before the auto_ptr instantiation:

Code:

---

class Foo {
};

---

---

Thanks bithub,


I think declaration of class (including constructor and destructor) is enough?

Quote:

---

Originally Posted by bithub

It still won't compile because you still have not defined the type before the auto_ptr is declared.

---

regards,
George

You realize that putting an incomplete definition or a forward declaration of a class, and then using that class is one the worst possible things you can do, right?
The compiler cannot call the constructor nor destructor (you get a warning) and you cannot call any member functions either (you get an error).

Thanks Elysia,


I do not agree with you, forward declaration is ok and we can make an incomplete class declaration and complement the implementation later.

Here is my code to show this idea.

Code:

---

#include <memory>
#include <iostream>

using namespace std;

class Foo {
public:
        Foo();
        ~Foo();
};

void func()
{

        auto_ptr<Foo> pf (new Foo());

        cout << "I am here. " << endl;

        return;
}

int main()
{
        func();

        return 0;
}

Foo::Foo()
{
}

Foo::~Foo()
{
}

---

Quote:

---

Originally Posted by Elysia

You realize that putting an incomplete definition or a forward declaration of a class, and then using that class is one the worst possible things you can do, right?
The compiler cannot call the constructor nor destructor (you get a warning) and you cannot call any member functions either (you get an error).

---

regards,
George

Quote:

---

Originally Posted by George2

Thanks Elysia,

I do not agree with you, forward declaration is ok and we can make an incomplete class declaration and complement the implementation later.

Here is my code to show this idea.

regards,
George

---

This is not a forward declaration.
This is the standard way of doing things.
What's bad is putting

class Foo;

And then actually using the class as you were doing before.

Thanks Elysia,


I have got your points about what means a forward declaration. :-)

Quote:

---

Originally Posted by Elysia

This is not a forward declaration.
This is the standard way of doing things.
What's bad is putting

class Foo;

And then actually using the class as you were doing before.

---

regards,
George

Quote:

---

Originally Posted by George2

I do not agree with you, forward declaration is ok and we can make an incomplete class declaration and complement the implementation later.

---

Well, Elysia is correct and you are misinterpreting your example.

The code in your example is valid because it does not make use of any forward declarations, and presents a complete class definition before func() attempts to instantiate your class.

The code;

Code:

---

class Foo {
public:
        Foo();
        ~Foo();
};

---

is neither a forward declaration nor an incomplete class declaration. It is a class definition.

The subsequent implementations of the constructor and destructor are also definitions of those (special) functions. The compiler does not need to see those definitions (in fact, they can be put into separate source files) because the previous class definition declares them, so they may be called.

Thanks grumpy,


Question answered.

Quote:

---

Originally Posted by grumpy

Well, Elysia is correct and you are misinterpreting your example.

The code in your example is valid because it does not make use of any forward declarations, and presents a complete class definition before func() attempts to instantiate your class.

The code;

Code:

---

class Foo {
public:
        Foo();
        ~Foo();
};

---

is neither a forward declaration nor an incomplete class declaration. It is a class definition.

The subsequent implementations of the constructor and destructor are also definitions of those (special) functions. The compiler does not need to see those definitions (in fact, they can be put into separate source files) because the previous class definition declares them, so they may be called.

---

regards,
George