struct in struct

[Gunnar G]

Hello.
My compiler (GCC 3.3.*) does not complain about the following:

#include <iostream>
#include <vector>
using namespace std;

struct X{
int a,b,c;
vector<X> pp;
};

int main(){
X a;
}
So there is not a problem with this self-refering struct, why?
Must not vector know the size of what it should contain?

[Leor Zolman]

On Tue, 01 Jun 2004 03:50:03 GMT, Gunnar G <de****@comhem. se> wrote:

Which, I believe,
is what Gunnar G was reporting for an *empty* container.

> cat self.cc #include <iostream>

template <typename T>
struct myVector {
T a[1];
};

struct X{
int a,b,c;
myVector<X> pp;
};

int main(int argc, char* argv[]){
X a;
return 0;
}

> g++ -Wall -ansi -pedantic -o self self.cc

self.cc: In instantiation of `myVector<X>':
self.cc:10: instantiated from here
self.cc:5: error: `myVector<T>::a ' has incomplete type
self.cc:8: error: forward declaration of `struct X'
self.cc: In function `int main(int, char**)':
self.cc:14: warning: unused variable `X a'

is probably the case that Gunnar G was concerned about.

So, you get an error here since you are declaring the array T a[1], and that
implies that something (the compiler?) would have to know the size of the
"T" in order to allocate memory?

Right. "myVector" contains a data declaration
T a[1];
(which doesn't need to be an array; a simple
T a;
would have similar results for the purpose of this example) that requires
a complete definition for the type T, which, at the point of pp's
declaration, is not available.
But with a STL-vector , it uses (perhaps
pointers) so it would not have to know the size, or the size is easy to
find, since it's just an sizeof(int)+siz eof(X-pointer)+overhe ad ?

Right, std::vector would not have to know the size of its value_type at the
point of pp's declaration in your original example.
-leor
--
Leor Zolman --- BD Software --- www.bdsoft.com
On-Site Training in C/C++, Java, Perl and Unix
C++ users: download BD Software's free STL Error Message Decryptor at:
www.bdsoft.com/tools/stlfilt.html

[Denis Remezov]

Gunnar G wrote:

Which, I believe,
is what Gunnar G was reporting for an *empty* container.

> cat self.cc

#include <iostream>

template <typename T>
struct myVector {
T a[1];
};

struct X{
int a,b,c;
myVector<X> pp;
};

int main(int argc, char* argv[]){
X a;
return 0;
}

> g++ -Wall -ansi -pedantic -o self self.cc

self.cc: In instantiation of `myVector<X>':
self.cc:10: instantiated from here
self.cc:5: error: `myVector<T>::a ' has incomplete type
self.cc:8: error: forward declaration of `struct X'
self.cc: In function `int main(int, char**)':
self.cc:14: warning: unused variable `X a'

is probably the case that Gunnar G was concerned about.

So, you get an error here since you are declaring the array T a[1], and that
implies that something (the compiler?) would have to know the size of the
"T" in order to allocate memory? But with a STL-vector , it uses (perhaps
pointers) so it would not have to know the size, or the size is easy to
find, since it's just an sizeof(int)+siz eof(X-pointer)+overhe ad ?

I think there is a way to break your original example by requiring the
template parameter to be a complete type for the purpose of vector's member
specification. Imagine an implementation like this:

template <typename T, class Allocator = allocator <T> >
class vector {
enum {
element_size = sizeof(T)
};

//...
};

I haven't decided why anyone would want to do that, but wouldn't it
still be a conforming implementation?

Denis

[Wouter Lievens]

"E. Robert Tisdale" <E.************ **@jpl.nasa.gov > schreef in bericht
news:c9******** **@nntp1.jpl.na sa.gov...

Leor Zolman wrote:

Gunnar G wrote:

My compiler (GCC 3.3.*) does not complain about the following:

#include <iostream>
#include <vector>
using namespace std;

struct X{
int a,b,c;
vector<X> pp;
};

int main(){
X a;
return 0;
}

So there is not a problem with this self-refering struct, why?
Must not vector know the size of what it should contain?
Ah, but not /yet/. At the point where pp is declared,
there's nothing yet happening where the vector "needs to know" the size of X. Go take a look at std::vector's class definition
in whatever lib (gcc, I guess) you're using,
and you'll see that it probably makes use of a pointer to X,
but you won't see any X objects themselves declared in the class definition.
Are you saying that this behavior is implementation dependent?

No, the size of std::vector<T> is a constant. It does not change during
run-time execution, because all classes have a constant size. The elemens an
std::vector contains are located on the heap.
By the time it needs to specialize member functions such as push_back
[say, for example, if you were to add this line to main:
a.pp.push_back( X());
] then X is a complete type and it works.

[John Carson]

"Gunnar G" <de****@comhem. se> wrote in message
news:DZ******** ************@ne wsc.telia.net

Hello.
My compiler (GCC 3.3.*) does not complain about the following:

#include <iostream>
#include <vector>
using namespace std;

struct X{
int a,b,c;
vector<X> pp;
};

int main(){
X a;
}
So there is not a problem with this self-refering struct, why?
Must not vector know the size of what it should contain?

This was discussed some time ago both on this newsgroup and
comp.lang.c++.m oderated. There are two statements in the standard that are
relevant. The first is in 14.3.1 p2 of the 2003 standard. It says:

"[Note: a template type argument may be an incomplete type (3.9). ]"

The second is in section 17.4.3.6 of the standard. It says:

"In certain cases (replacement functions, handler functions, operations on
types used to instantiate standard library template components), the C + +
Standard Library depends on components supplied by a C + + program. If these
components do not meet their requirements, the Standard places no
requirements on the implementation.

"In particular, the effects are undefined in the following cases:
[snip]
- if an incomplete type (3.9) is used as a template argument when
instantiating a template component."

The second quotation prompts the question of exactly when "instantiat ion"
takes place. The newsgroup discussion suggested that the use of the
vector<X> pp; in your struct declaration DOES constitute instantiation for
the purposes of the quoted passage.

The general conclusion from the discussion (as interpreted by me) was:

1. In general, there is no language bar against template arguments that are
incomplete types in the contexts that you are discussing,
2. Whether or not incomplete types are allowed in this context depends on
the details of the template class concerned. The passage from 17.4.3.6 says
that the standard library is not required to accept incomplete types as
arguments. This was originally because it was not known if the standard
library could be implemented in such a way as to allow incomplete types (in
fact, there were some claims that vectors could not be implemented in such a
way).

The Dinkumware library (which ships with VC++ 7.1, among others) does allow
containers with incomplete types in the context you have described. gcc
apparently does too. Now that its technical feasibility has been shown, it
is likely to make it into the standard. For the present, however, the
property is implementation-dependent.

Two of the original discussions are here (I seem to remember a third thread
but can't find it):

http://groups.google.com/groups?hl=e....nz%26rnum%3D4

and here

http://groups.google.com/groups?hl=e...com%26rnum%3D1
--
John Carson
1. To reply to email address, remove donald
2. Don't reply to email address (post here instead)

[josh]

E. Robert Tisdale wrote:

> cat self.cc

#include <iostream>
#include <vector>

struct X{
int a,b,c;
std::vector<X> pp(1);
};

int main(int argc, char* argv[]){
X a;
return 0;
}

> g++ -Wall -ansi -pedantic -o self self.cc

self.cc:6: error: invalid data member initialization
self.cc:6: error: (use `=' to initialize static data members)

gcc seems pretty clear on the matter: you can't initialize data members
like that.

try:
struct X{
int a,b,c;
std::vector<int > pp(1);
};

Same error, I'll bet.

-josh