Incomplete type specification

I'm working my way through Eckel's "Thinking in C++ " book at the moment and if I interpreted it correctly, the following code should be incorrect (compiler-warning for the "void g(X ex);"):

Code:

struct X;

struct Y {
  void f(X*);
  void g(X ex);
};


struct X { // Definition
private:
  int i;
public:
  friend void Y::f(X*); 
  friend void Y::g(X);
  void initialize();
 };


void Y::g(X ex) {
  ex.i = 3333;
}

But at least the GCC compiler can work with this. According to the book, the Y::g declaration is supposed to fail because the compiler needs to know "the entire structure definition of X, to know the size and how to pass it", whereas Y::f only takes the address of an X object and the compiler can handle this without the definition of X.
My question is if the code above is valid (would work on other compilers as well) or if it's just GCC that can handle this.

edit: nevermind, i grossly misread your post

This problem would only occur if you didn't have

Code:

struct X;

at the start.

Actually I think this particular error would occur if he didn't have this:

Code:

struct X { // Definition
private:
  int i;
public:
  friend void Y::f(X*); 
  friend void Y::g(X);
  void initialize();
 };

The error you describe happens when you are attempting to create an instance of an object without your compiler knowing what the object will look like. It would be like me asking you for a car that I like and giving you no further detail than that.

I would say that a function declaration does not need complete types for parameters and return value, but I found no place in the standard to back me up.

Yeah even without the support from the standard, it seems to be the typical behavior of many compilers.

It would be a error if you try do define functions inside the class, for example:

Code:

struct X;

struct Y {
  void f(X*);
  void g(X ex){ ex.i = 3333; }
};


struct X { // Definition
private:
  int i;
public:
  friend void Y::f(X*); 
  friend void Y::g(X);
  void initialize();
};

> It would be a error if you try do define functions inside the class
Well...I'd say no, but you are right in this instance. But the reason for that it being erroneous in this context is because your compiler has no idea what an X is. Inlining functions is otherwise not illegal.

Well, the error is in the define part, not in the inside the class part.

Yep The only way that would work is if you define struct X before defining struct Y. Compilers are not mind readers. One other little detail, function would be altering a local copy of the X object, thus even if it were written correctly enough to compile, I don't think it would do what you intended for it to do.

I doubt Mortissus intended it to do anything

It was just an example of a kind of error that I had before.

Figured as much, its just good to keep people from feverishly copying code that is known to not work, then later posting:

I need help!

Code:

struct X;

struct Y {
  void f(X*);
  void g(X ex){ ex.i = 3333; }
};


struct X { // Definition
private:
  int i;
public:
  friend void Y::f(X*); 
  friend void Y::g(X);
  void initialize();
};

wont work!! I need this working before class starts in 37 seconds! Please help!!

Thanks for the input.

So it seems to be safe to ignore the book's statement that this is only possible with pointers to X. Or might this be a case of "you can do it, but you shouldn't do it"? Though I wouldn't see why...

Originally Posted by New++

I'm working my way through Eckel's "Thinking in C++ " book at the moment and if I interpreted it correctly, the following code should be incorrect (compiler-warning for the "void g(X ex);"):

Code:

struct X;

struct Y {
  void f(X*);
  void g(X ex);
};


struct X { // Definition
private:
  int i;
public:
  friend void Y::f(X*); 
  friend void Y::g(X);
  void initialize();
 };


void Y::g(X ex) {
  ex.i = 3333;
}

But at least the GCC compiler can work with this. According to the book, the Y::g declaration is supposed to fail because the compiler needs to know "the entire structure definition of X, to know the size and how to pass it", whereas Y::f only takes the address of an X object and the compiler can handle this without the definition of X.
My question is if the code above is valid (would work on other compilers as well) or if it's just GCC that can handle this.

Unless my brain is deader than usual in yor example the compielr does indeed know "the entire structre definition of X" (it doesn't matter if some of it is private)

Originally Posted by Mortissus

It would be a error if you try do define functions inside the class, for example:

Code:

struct X;

struct Y {
  void f(X*);
  void g(X ex){ ex.i = 3333; }
};


struct X { // Definition
private:
  int i;
public:
  friend void Y::f(X*); 
  friend void Y::g(X);
  void initialize();
};

In this case the compiler doesn't know the definition of X and therefore throws an error when compiling Y::g().