I&#39;m trying to use a typedef from a subclass in my project, I&#39;ve isolated my problem in the example below.

Does anyone know where I&#39;m going wrong?

    template&lt;typename Subclass&gt;
    class A {
    	public:
    		//Why doesn&#39;t it like this?
    		void action(typename Subclass::mytype var) {
    			(static_cast&lt;Subclass*&gt;(this))-&gt;do_action(var);
    		}
    };
    
    class B : public A&lt;B&gt; {
    	public:
    		typedef int mytype;
    
    		B() {}
    
    		void do_action(mytype var) {
    			// Do stuff
    		}
    };
    
    int main(int argc, char** argv) {
    	B myInstance;
    	return 0;
    }

This is the output I get:

    sean@SEAN-PC:~/Documents/LucadeStudios/experiments$ g++ -o test test.cpp
    test.cpp: In instantiation of ‘A&lt;B&gt;’:
    test.cpp:10:   instantiated from here
    test.cpp:5: error: invalid use of incomplete type ‘class B’
    test.cpp:10: error: forward declaration of ‘class B’



invalid use of incomplete type

What is the use of typedef keyword in C ?
When is it needed?

What is the use of typedef?

I&#39;m reading code of a C++ project and it contains some code of the following form:

    namespace ns {
        class A {};
        class B {};
    }

    struct C {
        typedef ns::A* ns::B::* type;
    };

Can someone explain the meaning of the `typedef` line? `type` seems to be some kind of pointer to member of `ns::B` which points to `ns::A`, but I&#39;m not sure.

Class `A` and `B` in the real code are not empty, but I think it&#39;s not relevant here. And here is a [live example](http://coliru.stacked-crooked.com/a/d2956ed3017bf618).

A confusing typedef involves class scope

I am writing a program and I would really prefer to write in C++, however, I&#39;m required to include a C header that redefines bool:  

    # define false 0
    # define true  1
    typedef int bool;

The obvious solution would be to edit the header to say:

    #ifndef __cplusplus
    # define false 0
    # define true  1
    typedef int bool;
    #endif

but, alas, since the library is read-only I cannot.

Is there a way I can tell gcc to ignore this typedef? Or, can I write most functions in C++ and then make a C wrapper for the two? Or, should I suck it up and write the thing in C?

Can I mimic a C header that redefines bool in C++?

I am a beginner in C programming and I know the difference between `struct` type declaration and `typedef` struct declaration. I came across to know an answer saying that if we define a `struct` like:

    typedef struct { 
        some members;
    } struct_name;

Then it will be like providing an alias to an anonymous struct (as it is not having a tag name). So it can&#39;t be used for forward declaration. I don&#39;t know what the *forward declaration* means.

Also, I wanted to know that for the following code:
        
    typedef struct NAME { 
        some members;
    } struct_alias;

Is there any difference between `NAME` and `struct_alias`? Or are both equal as 
`struct_alias` is an alias of  struct NAME ? 

Furthermore, can we declare a variable of type `struct NAME` like these:

    struct_alias variable1;

and/or like:

    struct NAME variable2;

or like:

    NAME variable3; 


What is &#39;forward declaration&#39; and the difference between &#39;typedef struct X&#39; and &#39;struct X&#39;?

I&#39;m using shared_ptr and STL extensively in a project, and this is leading to over-long, error-prone types like `shared_ptr&lt; vector&lt; shared_ptr&lt;const Foo&gt; &gt; &gt;` (I&#39;m an ObjC programmer by preference, where long names are the norm, and still this is way too much.) It would be much clearer, I believe, to consistently call this `FooListPtr` and documenting the naming convention that &quot;Ptr&quot; means shared_ptr and &quot;List&quot; means vector of shared_ptr.

This is easy to typedef, but it&#39;s causing headaches with the headers. I seem to have several options of where to define `FooListPtr`:

* Foo.h. That entwines all the headers and creates serious build problems, so it&#39;s a non-starter.
* FooFwd.h (&quot;forward header&quot;). This is what _Effective C++_ suggests, based on iosfwd.h. It&#39;s very consistent, but the overhead of maintaining twice the number of headers seems annoying at best.
* Common.h (put all of them together into one file). This kills reusability by entwining a lot of unrelated types. You now can&#39;t just pick up one object and move it to another project. That&#39;s a non-starter.
* Some kind of fancy #define magic that typedef&#39;s if it hasn&#39;t already been typedefed. I have an abiding dislike for the preprocessor because I think it makes it hard for new people to grok the code, but maybe....
* Use a vector subclass rather than a typedef. This seems dangerous...

Are there best practices here? How do they turn out in real code, when reusability, readability and consistency are paramount?

I&#39;ve marked this community wiki if others want to add additional options for discussion.

Header file best practices for typedefs

I am confused when should I add the trailing `_t` to `typedef`&#39;ed types?

For example, should I do this:

    typedef struct image image_t;

or this:

    typedef struct image image;

What are the general rules?

Another example, should I do this:

    typdef enum { ARRAY_CLOSED, ARRAY_OPEN, ARRAY_HALFOPEN } array_type_t;

or this:

    typdef enum { ARRAY_CLOSED, ARRAY_OPEN, ARRAY_HALFOPEN } array_type;


Please enlighten me.

Thanks, Boda Cydo.


If I do a `typedef` in C or C++, when should I add `_t` at the end of typedef&#39;ed type?

I came across a new use of the keyword **typedef** in C++.

What does this typedef statement mean ?

    int typedef foo;

Unusual typedef use in C++

It had been a while since GCC caught me with this one, but it just happened today. But I&#39;ve never understood why GCC requires typedef typename within templates, while VS and I guess ICC don&#39;t. Is the typedef typename thing a &quot;bug&quot; or an overstrict standard, or something that is left up to the compiler writers?

For those who don&#39;t know what I mean here is a sample:

    template&lt;typename KEY, typename VALUE&gt;
    bool find(const std::map&lt;KEY,VALUE&gt;&amp; container, const KEY&amp; key)
    {
        std::map&lt;KEY,VALUE&gt;::const_iterator iter = container.find(key);
        return iter!=container.end();
    }

The above code compiles in VS (and probably in ICC), but fails in GCC because it wants it like this:

    template&lt;typename KEY, typename VALUE&gt;
    bool find(const std::map&lt;KEY,VALUE&gt;&amp; container, const KEY&amp; key)
    {
        typedef typename std::map&lt;KEY,VALUE&gt;::const_iterator iterator; //typedef typename
        iterator iter = container.find(key);
        return iter!=container.end();
    }


Note: This is not an actual function I&#39;m using, but just something silly that demonstrates the problem.

Why do I need to use typedef typename in g++ but not VS?

I am trying to understand what this means, the code I am looking at has

in `.h`


    typedef void (*MCB)();
    static MCB     m_process;


in `.C`

    MCB Modes::m_process = NULL;


And sometimes when I do

    m_process();

I get segmentations fault, it&#39;s probably because the memory was freed, how can I debug when it gets freed?

What does &quot;typedef void (*Something)()&quot; mean

I would like a standard reference why the following code triggers a compliance warning in C (tested with `gcc -pedantic`; &quot;typedef redefinition&quot;), but is fine in C++ (`g++ -pedantic`):

    typedef struct Foo Foo;
    typedef struct Foo Foo;
    
    int main() { return 0; }

Why can I not define a `typedef` repeatedly in C?

(This has practical implications for the header structuring of a [C project](http://sc2.svn.sourceforge.net/viewvc/sc2/trunk/sc2/src/libs/resource/index.h?revision=3704&amp;view=markup).)

Repeated typedefs - invalid in C but valid in C++?

Coming from a C and C++ background, I found judicious use of **`typedef`** to be incredibly helpful.  Do you know of a way to achieve similar functionality in Java, whether that be a Java mechanism, pattern, or some other effective way you have used?

Is there a Java equivalent or methodology for the typedef keyword in C++?

I know that in C++11 we can now use `using` to write type alias, like `typedef`s:

    typedef int MyInt;

Is, from what I understand, equivalent to:

    using MyInt = int;

And that new syntax emerged from the effort to have a way to express &quot;template typedef&quot;:

    template&lt; class T &gt; using MyType = AnotherType&lt; T, MyAllocatorType &gt;;

But, with the first two non-template examples, are there any other subtle differences in the standard? For example, `typedef`s do aliasing in a &quot;weak&quot; way. That is it does not create a new type but only a new name (conversions are implicit between those names).

Is it the same with `using` or does it generate a new type? Are there any differences?

What is the difference between &#39;typedef&#39; and &#39;using&#39; in C++11?

What is the advantage of using `uint8_t` over `unsigned char` in C?

I know that on almost every system `uint8_t` is just a typedef for `unsigned char`,
so why use it?

uint8_t vs unsigned char

Why won&#39;t the compiler let me forward declare a typedef?

Assuming it&#39;s impossible, what&#39;s the best practice for keeping my inclusion tree small?

Forward declaration of a typedef in C++

I have always been a bit stumped when I read other peoples&#39; code which had typedefs for pointers to functions with arguments. I recall that it took me a while to get around to such a definition while trying to understand a numerical algorithm written in C a while ago. So, could you share your tips and thoughts on how to write good typedefs for pointers to functions (Do&#39;s and Do not&#39;s), as to why are they useful and how to understand others&#39; work? Thanks!

Understanding typedefs for function pointers in C

I don&#39;t think I fundamentally understand what an `enum` is, and when to use it.  

For example:

    typedef enum {
        kCircle,
        kRectangle,
        kOblateSpheroid
    } ShapeType;

What is really being declared here?


What is a typedef enum in Objective-C?

I have to define a 24-bit data type.I am using `char[3]` to represent the type. Can I typedef `char[3]` to `type24`? I tried it in a code sample. I put `typedef char[3] type24;` in my header file. The compiler did not complain about it. But when I defined a function `void foo(type24 val) {}` in my C file, it did complain. I would like to be able to define functions like `type24_to_int32(type24 val)` instead of `type24_to_int32(char value[3])`.

typedef fixed length array

I&#39;m a beginner in C programming, but I was wondering what&#39;s the difference between using `typedef` when defining a structure versus not using `typedef`. It seems to me like there&#39;s really no difference, they accomplish the same goal.


    struct myStruct{
        int one;
        int two;
    };

vs.

    typedef struct{
        int one;
        int two;
    }myStruct;

typedef struct vs struct definitions

In **C++**, is there any difference between:

    struct Foo { ... };

and:
    
    typedef struct { ... } Foo;

Difference between &#39;struct&#39; and &#39;typedef struct&#39; in C++?

I haven&#39;t written any C++ in years and now I&#39;m trying to get back into it. I then ran across this and thought about giving up:

    typedef enum TokenType
    {
        blah1   = 0x00000000,
        blah2   = 0X01000000,
        blah3   = 0X02000000
    } TokenType;

What is this? Why is the `typedef` keyword used here? Why does the name `TokenType` appear twice in this declaration? How are the semantics different from this:

    enum TokenType
    {
        blah1 = 0x00000000,
        blah2=0x01000000,
        blah3=0x02000000
    };


Why do you use typedef when declaring an enum in C++?

I&#39;d like to write this

    typedef void (*FunctionPtr)();

using `using`. How would I do that?

How do I typedef a function pointer with the C++11 using syntax?

Something I have found myself doing often lately is declaring typedefs relevant to a particular class inside that class, i.e.

    class Lorem
    {
        typedef boost::shared_ptr&lt;Lorem&gt; ptr;
        typedef std::vector&lt;Lorem::ptr&gt;  vector;

    //
    // ...
    //
    };

These types are then used elsewhere in the code:

    Lorem::vector lorems;
    Lorem::ptr    lorem( new Lorem() );
    
    lorems.push_back( lorem );

Reasons I like it:

- It reduces the noise introduced by the class templates, `std::vector&lt;Lorem&gt;` becomes `Lorem::vector`, etc.
- It serves as a statement of intent - in the example above, the Lorem class is intended to be reference counted via `boost::shared_ptr` and stored in a vector.
- It allows the implementation to change - i.e. if Lorem needed to be changed to be intrusively reference counted (via `boost::intrusive_ptr`) at a later stage then this would have minimal impact to the code.
- I think it looks &#39;prettier&#39; and is arguably easier to read.

Reasons I don&#39;t like it:

- There are sometimes issues with dependencies - if you want to embed, say, a `Lorem::vector` within another class but only need (or want) to forward declare Lorem (as opposed to introducing a dependency on its header file) then you end up having to use the explicit types (e.g. `boost::shared_ptr&lt;Lorem&gt;` rather than `Lorem::ptr`), which is a little inconsistent.
- It may not be very common, and hence harder to understand?

I try to be objective with my coding style, so it would be good to get some other opinions on it so I can dissect my thinking a little bit.

Internal typedefs in C++ - good style or bad style?

I haven&#39;t been writing C for very long, and so I&#39;m not sure about how I should go about doing these sorts of recursive things... I would like each cell to contain another cell, but I get an error along the lines of &quot;field &#39;child&#39; has incomplete type&quot;. What&#39;s up?

    typedef struct Cell {
      int isParent;
      Cell child;
    } Cell;

self referential struct definition?

Assuming that I have a typedef declared in my .h file as such:

    typedef enum {
      JSON,
      XML,
      Atom,
      RSS
    } FormatType;

I would like to build a function that converts the numeric value of the typedef to a string.  For example, if the message `[self toString:JSON]` was sent; it would return &#39;JSON&#39;.

The function would look something like this:

    -(NSString *) toString:(FormatType)formatType {
      //need help here
      return [];
    }

Incidentally, if I try this syntax 

    [self toString:FormatType.JSON];

to pass the typedef value to the method, I get an error.  What am I missing?

Convert objective-c typedef to its string equivalent

I wonder if `typedef` and `#define` are the same in [tag:c]?

Are typedef and #define the same in c?

According to [cppreference.com](http://en.cppreference.com/w/cpp/types/size_t) `size_t` is defined in several headers, namely


    &lt;cstddef&gt;
    &lt;cstdio&gt;
    &lt;cstring&gt;
    &lt;ctime&gt;

And, since C++11, also in

    &lt;cstdlib&gt;
    &lt;cwchar&gt; 

First of all, I wonder why this is the case. Isn&#39;t this in contradiction to the [DRY](https://en.wikipedia.org/wiki/Don&#39;t_repeat_yourself) principle?

Which one of the above headers should I include to use `size_t`? Does it matter at all?

Which header should I include for `size_t`?

I&#39;m learning how to dynamically load DLL&#39;s but what I don&#39;t understand is this line

    typedef void (*FunctionFunc)();

I have a few questions. If someone is able to answer them I would be grateful.

1. Why is `typedef` used?
2. The syntax looks odd; after `void` should there not be a function name or something? It looks like an anonymous function.
3. Is a function pointer created to store the memory address of a function?

So I&#39;m confused at the moment; can you clarify things for me?

Typedef function pointer?

I have seen many programs consisting of structures like the one below

    typedef struct 
    {
        int i;
        char k;
    } elem;

    elem user;

Why is it needed so often? Any specific reason or applicable area?


Why should we typedef a struct so often in C?

I was snooping through my MSP430 microcontroller&#39;s header files, and I ran into this in `&lt;setjmp.h&gt;`:

    /* r3 does not have to be saved */
    typedef struct
    {
    	uint32_t __j_pc; /* return address */
    	uint32_t __j_sp; /* r1 stack pointer */
    	uint32_t __j_sr; /* r2 status register */
    	uint32_t __j_r4;
    	uint32_t __j_r5;
    	uint32_t __j_r6;
    	uint32_t __j_r7;
    	uint32_t __j_r8;
    	uint32_t __j_r9;
    	uint32_t __j_r10;
    	uint32_t __j_r11;
    } jmp_buf[1]; /* size = 20 bytes */

I understand that it declares an anonymous struct and typedef&#39;s it to `jmp_buf`, but I can&#39;t figure out what the `[1]` is for. I know it declares `jmp_buf` to be an array with one member (of this anonymous struct), but I can&#39;t imagine what it&#39;s used for. Any ideas?

What&#39;s the purpose of this [1] at the end of struct declaration?

I have read the description, and I understand that it is a function-type alias.

- A typedef, or function-type alias, gives a function type a name that you can use when declaring fields and return types. A typedef retains type information when a function type is assigned to a variable.

- http://www.dartlang.org/docs/spec/latest/dart-language-specification.html#kix.yyd520hand9j

But how do I use it? Why declaring fields with a function-type? When do I use it? What problem does it solve? 

I think I need one or two real code examples.

What are function typedefs / function-type aliases in Dart?

If I require a custom type in Swift, that I could `typedef`, how do I do it? (Something like a closure syntax typedef)

How do I declare typedef in Swift

I looked through some code and noticed that the convention was to turn pointer types like

    SomeStruct* 

into

    typedef SomeStruct* pSomeStruct;


Is there any merit to this?

Is it a good idea to typedef pointers?

I have a class

    template&lt;size_t N, size_t M&gt;
    class Matrix {
        // ....
    };

I want to make a `typedef` which creates a `Vector` (column vector) which is equivalent to a `Matrix` with sizes N and 1. Something like that:

    typedef Matrix&lt;N,1&gt; Vector&lt;N&gt;;

Which produces compile error. The following creates something similar, but not exactly what I want:

    template &lt;size_t N&gt;
    class Vector: public Matrix&lt;N,1&gt;
    { };

Is there a solution or a not too expensive workaround / best-practice for it? 

C++ template typedef

How should I `typedef` a `template class` ? Something like:

    typedef std::vector myVector;  // &lt;--- compiler error
I know of 2 ways:

    (1) #define myVector std::vector // not so good
    (2) template&lt;typename T&gt;
        struct myVector { typedef std::vector&lt;T&gt; type; }; // verbose
Do we have anything better in C++0x ?


How to typedef a template class?

I&#39;m having trouble with enum visibility in an Objective-C program. I have two header files, and one defines a `typedef enum`. Another file needs to use the `typedef`&#39;d type.

In straight C, I would simply `#include` the other header file, but in Objective-C, it&#39;s recommended not to use `#import` between header files, instead using forward `@class` declarations as needed. However, I can&#39;t figure out how to forward-declare an enumeration type.

I don&#39;t need the actual enumerated values, except in the corresponding `.m` implementation file, where I can safely `#import` away. So how can I get the `typedef enum` to be recognized in the header? 

Forward-declare enum in Objective-C

In my years of C++ (MFC) programming in I never felt the need to use `typedef`, so I don&#39;t really know what is it used for. Where should I use it? Are there any real situations where the use of `typedef` is preferred? Or is this really more a C-specific keyword?

When should I use typedef in C++?

In a C++ reference page they provide some typedef examples and I&#39;m trying to understand what they mean.
    
    // simple typedef
    typedef unsigned long mylong;
     
     
    // more complicated typedef
    typedef int int_t, *intp_t, (&amp;fp)(int, mylong), arr_t[10];

So the simple typedef (the first declaration) I understand.

But what are they declaring with the second one (repeated below)?

    typedef int int_t, *intp_t, (&amp;fp)(int, ulong), arr_t[10];

Particularly what does `(&amp;fp)(int, mylong)` mean?

What does this typedef statement mean?

I read the [Wikipedia article][1] about the curiously recurring template pattern in C++ for doing static (read: compile-time) polymorphism. I wanted to generalize it so that I could change the return types of the functions based on the derived type. (This seems like it should be possible since the base type knows the derived type from the template parameter). Unfortunately, the following code won&#39;t compile using MSVC 2010 (I don&#39;t have easy access to gcc right now so I haven&#39;t tried it yet). Anyone know why?

    template &lt;typename derived_t&gt;
    class base {
    public:
        typedef typename derived_t::value_type value_type;
        value_type foo() {
            return static_cast&lt;derived_t*&gt;(this)-&gt;foo();
        }
    };

    template &lt;typename T&gt;
    class derived : public base&lt;derived&lt;T&gt; &gt; {
    public:
        typedef T value_type;
        value_type foo() {
            return T(); //return some T object (assumes T is default constructable)
        }
    };

    int main() {
        derived&lt;int&gt; a;
    }

BTW, I have a work-around using extra template parameters, but I don&#39;t like it---it will get very verbose when passing many types up the inheritance chain.
    
    template &lt;typename derived_t, typename value_type&gt;
    class base { ... };

    template &lt;typename T&gt;
    class derived : public base&lt;derived&lt;T&gt;,T&gt; { ... };

**EDIT:**

The error message that MSVC 2010 gives in this situation is `error C2039: &#39;value_type&#39; : is not a member of &#39;derived&lt;T&gt;&#39;`

g++ 4.1.2 (via [codepad.org](http://codepad.org)) says `error: no type named &#39;value_type&#39; in &#39;class derived&lt;int&gt;&#39;`

  [1]: http://en.wikipedia.org/wiki/Curiously_Recurring_Template_Pattern

C++ static polymorphism (CRTP) and using typedefs from derived classes

In a C++ header file, I am seeing this code:

    typedef typename _Mybase::value_type value_type;


Now, as I understand, quoting from &#171; *C++ the Complete Reference* &#187; by Schildt. `typename` can be substituted by keyword class, the second use of `typename` is to inform the compiler that a name used in a template declaration is a type name rather than an object name. 

Similarly, you can define new data type names by using the keyword `typedef`. You are not
actually creating a new data type, but rather defining a new name for an existing
type. 

However, can you explain exactly what is the meaning of the above line of code, where `typedef` and `typename` are combined together. And what does the &quot;`::`&quot; in the statement imply?




C++ - meaning of a statement combining typedef and typename

I&#39;m trying to define base class, which contains typedef&#39;s only. 

    template&lt;typename T&gt;
    class A
    {
    public:
        typedef std::vector&lt;T&gt; Vec_t;
    };
    
    
    template&lt;typename T&gt;
    class B : public A&lt;T&gt;
    {
    private:
        Vec_t v;  // fails - Vec_t is not recognized
    };

Why in B I receive an error that Vec_t is not recognized and I need to write it explicitly?

    typename A&lt;T&gt;::Vec_t v;


Propagating &#39;typedef&#39; from based to derived class for &#39;template&#39;

Is there a typedef equivalent in C#, or someway to get some sort of similar behaviour? I&#39;ve done some googling, but everywhere I look seems to be negative. Currently I have a situation similar to the following:

    class GenericClass&lt;T&gt; 
    {
        public event EventHandler&lt;EventData&gt; MyEvent;
        public class EventData : EventArgs { /* snip */ }
        // ... snip
    }

Now, it doesn&#39;t take a rocket scientist to figure out that this can very quickly lead to a lot of typing (apologies for the horrible pun) when trying to implement a handler for that event. It&#39;d end up being something like this:

    GenericClass&lt;int&gt; gcInt = new GenericClass&lt;int&gt;;
    gcInt.MyEvent += new EventHandler&lt;GenericClass&lt;int&gt;.EventData&gt;(gcInt_MyEvent);
    // ...

    private void gcInt_MyEvent(object sender, GenericClass&lt;int&gt;.EventData e)
    {
        throw new NotImplementedException();
    }

Except, in my case, I was already using a complex type, not just an int. It&#39;d be nice if it were possible to simplify this a little...

Edit: ie. perhaps typedefing the EventHandler&lt;T&gt; instead of needing to redefine it to get similar behaviour.

Equivalent of typedef in C#

I&#39;ve seen a lot of questions on this but I&#39;m going to ask the question differently without specific code.  Is there a way of ***EASILY*** determining what is causing the type to be incomplete?  In my case I&#39;m using someone elses code and I&#39;m completely sure I don&#39;t have the headers right, but (since computers do this stuff much faster and better than human eyeballs) is there a way to get the compiler to say, &quot;hey you *think* you have type X at line 34 but that&#39;s actually *missing*.&quot;  The error itself only shows up when you assign, which isn&#39;t very helpful.

dereferencing pointer to incomplete type

In C++ the following code gives a compiler error:

    void destruct1 (int * item)
    {
      item-&gt;~int();
    }

This code is nearly the same, I just typedef the int to another type and something magic happens:

    typedef int myint;
    
    void destruct2 (myint * item)
    {
      item-&gt;~myint();
    }


Why does the second code work? Does an int get a destructor just because it has been typedefed?

In case you wonder why one ever would like to do this: This comes from refactoring C++ code. We&#39;re removing the standard heap and replacing it with selfmade pools. This requires us to call placement-new and the destructors. I know that calling destructors for primitive types is useless, but we want them in the code nevertheless in case we later replace PODs with real classes.

Finding out that naked int&#39;s don&#39;t work but typedefed ones do was quite a surprise.

Btw - I have a solution that involves template-functions. We just typedef inside the template and everything is fine.


Destructors of builtin types (int, char etc..)

As the title says, I have this code:
```c
    typedef struct Book{
        int id;
        char title[256];
        char summary[2048];
        int numberOfAuthors;
        struct Author *authors;
    };


    typedef struct Author{
        char firstName[56];
        char lastName[56];
    };


    typedef struct Books{
        struct Book *arr;
        int numberOfBooks;
    };
```


I get these errors from gcc :

    bookstore.c:8:2: error: unknown type name ‘Author’
    bookstore.c:9:1: warning: useless storage class specifier in empty declaration [enabled by default]
    bookstore.c:15:1: warning: useless storage class specifier in empty declaration [enabled by default]
    bookstore.c:21:2: error: unknown type name ‘Book’
    bookstore.c:23:1: warning: useless storage class specifier in empty declaration [enabled by default]



No warnings and no errors occur if I change the typedefs like this:

```c
    typedef struct{
        char firstName[56];
        char lastName[56];
    } Author;
```

Having searched through _[C Programming Language, 2nd Edition][1]_ and googled for a couple of hours, I can&#39;t figure out why the first implementation won&#39;t work.
    
[1]:http://www.amazon.com/C-Programming-Language-2nd-Edition/dp/0131103628

C : typedef struct name {...}; VS typedef struct{...} name;

I&#39;ve seen both of the following two styles of declaring opaque types in C APIs. What are the various ways to declare opaque structs/pointers in C? Is there any clear advantage to using one style over the other?

Option 1
--------
    // foo.h
    typedef struct foo * fooRef;
    void doStuff(fooRef f);

    // foo.c
    struct foo {
        int x;
        int y;
    };

Option 2
--------
    // foo.h
    typedef struct _foo foo;
    void doStuff(foo *f);

    // foo.c
    struct _foo {
        int x;
        int y;
    };

Opaque C structs: various ways to declare them

Arrays of function pointers can be created like so:

    typedef void(*FunctionPointer)();
    FunctionPointer functionPointers[] = {/* Stuff here */};

What is the syntax for creating a function pointer array without using the `typedef`?

What&#39;s the syntax for declaring an array of function pointers without using a separate typedef?

Consider:

    #define MAXROW 20
    #define MAXCOL 60
    typedef State Grid[MAXROW+2] [MAXCOL+2]
    typedef enum state {DEAD,ALIVE} State

How do I use `typedef` and `typedef enum` in C? What does this part of the code do?


All Typedef Solutions on Gang of Coders

Total of 48 Typedef Solutions