typedef struct name name without a subsequent struct definition

Question

I found the following code at lines 153-154 in the libelf.h of the libelf library:

/* Descriptor for the ELF file.  */
typedef struct Elf Elf;

I was looking for a struct definition of Elf but did not find it.

Later in the code, Elf is used, e.g.

/* Return descriptor for ELF file to work according to CMD.  */
extern Elf *elf_begin (int __fildes, Elf_Cmd __cmd, Elf *__ref);

In the thread Why should we typedef a struct so often in C?, user "unwind" says:

Also note that while your example (and mine) omitted naming the struct itself, actually naming it is also useful for when you want to provide an > opaque type. Then you'd have code like this in the header, for instance:

typedef struct Point Point;

Point * point_new(int x, int y);

and then provide the struct declaration in the implementation file.

Yet, I couldnt find a definition of the struct Elf in any c file either.

What am I missing? What is the purpose of a typedef struct Name_xy Name_xy; without struct definition? Or is this impossible and I just did not find the struct definition?

---

Edit:

First, thank you for the numerous great replies. As my question was two-fold (at least), there are two answers:

1. I did not find the definition because I did not have the lib/private.h file (thanks @molbdnilo to point out that the definition is in there). I installed the sources of elfutils and not of libelf. It seems that the private.h is not included in the elfutils source package.
2. The answers from @Acrasidae, @sfjac, and @Matt McNabb explain the conceptual background (opaque type, encapsulation, minimising dependencies ...).

Answer 1

In C++, struct Elf should be sufficient to declare the type, which is all that is necessary to return a pointer to that type. This is often done to hide implementation from users of the header file that will not use the Elf functionality themselves but may just pass on the pointer. Coding in this fashion on eliminates unnecessary dependencies on header files that aren't actually used. This approach to minimizing header dependencies can have a big impact on compile times in large C++ projects.

As others have mentioned, typedef struct Elf Elfis a C thing, allowing you to elide the struct in future declarations.

Answer 2

typedef struct Elf Elf; is a short way of writing:

struct Elf;

typedef struct Elf Elf;

These lines do different things. The first one is usually called a forward declaration. It means that we can later have code such as:

// function prototype
struct Elf *elf_begin( stuff.... );

which prototypes a function that returns a pointer to struct Elf even though we do not actually know what is contained in the body of struct Elf. This is sometimes called opaque type and another instance of it is FILE * in the C standard library. There might be no definition of struct Elf anywhere.

The second part, typedef struct Elf Elf; is, as you say in your question, there to mainly avoid having to type struct all the time.

Answer 3

Is it defined in decl.h?

For example:

http://www.opensource.apple.com/source/dtrace/dtrace-96/head/libelf.h http://www.opensource.apple.com/source/dtrace/dtrace-118/libelf/decl.h

Answer 4

The possible explanation of this could be your project has some pre-compiled library files which contains definition of struct Elf.

Answer 5

What am I missing? What is the purpose of a typedef struct Name_xy Name_xy; without struct definition? Or is this impossible and I just did not find the struct definition?

In libelf.h, you have a declaration of an opaque type : Elf.

However, you do not find the definition of the Elf structure, and you are wondering why.

First of all, there is a definition somewhere, which looks like struct Elf{...};, however, you can not access to the definition because developers do not want you to access it. The only way you can use the contents of the Elf structure is because there is this declaration, typedef struct Elf Elf;, in libelf.h. By the way, struct Elf; is exactly the same, but with the typedef we know that there is more chance that the type is opaque.

A more illustrated example :

The header file :

/* libelf.h */
typedef struct Elf Elf;
extern Elf *elf_begin (int __fildes, Elf_Cmd __cmd, Elf *__ref);
etc...

The implementation file :

/* libelf.c */
struct Elf {
  char * something;
  FILE * whatever;
};

Elf *elf_begin (int __fildes, Elf_Cmd __cmd, Elf *__ref){
  /*doing something;*/
  /* ... */
}
etc...

This is exactly the principle of Encapsulation. The contents of this type are known and accessible only to the implementation of the API functions, clients (you) cannot directly access its contents. For developers, they have to compile a shared library, so you may find something like libelf.so somewhere (I do not know what the libelf do so I cannot help you on this). About the purpose of encapsulation, I advice you to read this.

I have nothing else in mind, but if you have more questions, do not hesitate.