previous declaration of Table was here / conflicting types for

[Michael.Z]

Anyone who can help:

Given a Table.h file I am writing a Table.c file.
I keep getting the compile error:

previous declaration of Table was here / conflicting types for
I think the problem was the result of two pieces of code.
First: typedef struct Table; /* in Table.c*/
Second: struct Table { /*struct definition */ } *Table; /* in
Table.h */

How can I solve the problems?

Here are the two files
/* * * * * * * * * * * * * * * * * * * * * * *
Header file:
* * * * * * * * * * * * * * * * * * * * * * */
#ifndef TABLE_H
#define TABLE_H
#include "bool.h"

typedef void * Table ;
typedef void * DataT ;

typedef struct {
// unsigned successful ; double unsuccessful ;
unsigned successfulNumer ator , successfulDenom inator ;
unsigned unsuccessfulNum erator , unsuccessfulDen ominator ;
} Perform ;

Table
makeTable ( int sizeTable , unsigned sizeData , int (*diff)() ,
unsigned (*hash)() , void * (*copy)() , void (*free)() ) ;
#endif

/* * * * * * * * * * * * * * * * * * * * * * *
Table.c
* * * * * * * * * * * * * * * * * * * * * * */

#include "Table.h"
typedef struct Table{
int sizeTable;
unsigned sizeData;
int (*diff)();
unsigned (*hash)();
void *(*copy)();
void (*free)();
} * Table;

Table
makeTable ( int sizeTable , unsigned sizeData , int (*diff)() ,
unsigned (*hash)() , void * (*copy)() , void (*free)() ) {
}

[ade ishs]

Michael.Z wrote:

Anyone who can help:

Given a Table.h file I am writing a Table.c file.
I keep getting the compile error:

previous declaration of Table was here / conflicting types for

#ifndef TABLE_H
#define TABLE_H

#include "bool.h"

typedef void * Table ;

You have it here, ...

[snip]

/* * * * * * * * * * * * * * * * * * * * * * *
Table.c
* * * * * * * * * * * * * * * * * * * * * * */

#include "Table.h"
typedef struct Table{
int sizeTable;
unsigned sizeData;
int (*diff)();
unsigned (*hash)();
void *(*copy)();
void (*free)();
} * Table;

And you also have it here.

In Table.h, you make Table a typedef of void *, and in Table.c, you make
Table a typedef of struct Table { ... } *.

[Flash Gordon]

Michael.Z wrote, On 03/05/08 08:22:

Anyone who can help:

Given a Table.h file I am writing a Table.c file.
I keep getting the compile error:

previous declaration of Table was here / conflicting types for
I think the problem was the result of two pieces of code.
First: typedef struct Table; /* in Table.c*/

This says that Table is a struct.

Second: struct Table { /*struct definition */ } *Table; /* in
Table.h */

This says it is a pointer to a struct, that is what the * means.

How can I solve the problems?

By not providing different definitions.

Here are the two files

<snip>

typedef void * Table ;

This is not what you said you had and is defining table as yet another type.

<snip>

typedef struct Table{
int sizeTable;
unsigned sizeData;
int (*diff)();
unsigned (*hash)();
void *(*copy)();
void (*free)();
} * Table;

This is what you said. However pointers to void and pointers to structs
are different things for the simple reason that void and struct are
different.

Also hiding pointers behind a typedef is generally considered a bad thing.
--
Flash Gordon

[Michael.Z]

Hi Flash Gordon:

Thanks for your reply.
The Table.c was required to be implemented as generic type. If I am
right, Table is declared as void * in header file, the reason is that,
when used later on, it can be casted to any other type of pointers.

The implementation of Table in Table.c was defined as pointer to
struct Table, because I need to implement the members of Table.

My professor told us, void * in header indicates a generic type.
He has some sample codes where List was typedef'd void pointer but the
definition was struct List Pointer:

/* Header file List.h*/
#ifndef LIST_H
#define LIST_H

#include "bool.h"

typedef void * List ;
typedef void * DataL ;
typedef void * ListIt ;

List makeList ( int , void * (*copy)() , void (*free)() ) ;
void freeList ( List ) ;
void clearList ( List ) ;

boolean accessList ( List , DataL , int ) ;
int lengthList ( List ) ;

boolean accessHead ( List , DataL ) ;
boolean insertHead ( List , DataL ) ;
boolean deleteHead ( List , DataL ) ;

/* not all the header file is copied here*/



/* List.c */

#include "bool.h"
#include <stdio.h>
#include <stdlib.h>

#ifndef DATA
#define DATA
typedef void * Data ;
#endif

typedef struct ListNode {
struct ListNode * next ; /* reference to following ListNode */
struct ListNode * previous ; /* reference to preceding ListNode */
Data dptr ;
} ListNode ;

typedef struct List {
ListNode * head ; /* Head end of List */
ListNode * tail ; /* Tail end of List */
int _lengthList ; /* number of items within List */
int _sizeData ; /* byte size of data to be stored */
void (*_freeData)( ) ; /* returns data item to heap */
void * (*_copyData)( ) ; /* copies data item to another */
} * List ;
Regards
Michael


On May 3, 2:32 am, Flash Gordon <[e-mail] te:

Michael.Z wrote, On 03/05/08 08:22:

Anyone who can help:

Given a Table.h file I am writing a Table.c file.
I keep getting the compile error:

previous declaration of Table was here / conflicting types for

I think the problem was the result of two pieces of code.
First:typedefst ruct Table; /* in Table.c*/

This says that Table is a struct.

Second: struct Table { /*struct definition */ } *Table; /* in
Table.h */

This says it is a pointer to a struct, that is what the * means.

How can I solve the problems?

By not providing different definitions.

Here are the two files

<snip>

typedefvoid * Table ;

This is not what you said you had and is defining table as yet another type.

<snip>

typedefstruct Table{
int sizeTable;
unsigned sizeData;
int (*diff)();
unsigned (*hash)();
void *(*copy)();
void (*free)();
} * Table;

This is what you said. However pointers to void and pointers to structs
are different things for the simple reason that void and struct are
different.

Also hiding pointers behind atypedefis generally considered a bad thing.
--
Flash Gordon

[Nick Keighley]

On 6 May, 03:33, "Michael.Z" <zhangqiuy...@g mail.comwrote:

Hi Flash Gordon:

The Table.c was required to be implemented as generic type.

I'm not sure what a "generic type" is and I have been programming
for quite a while.

>*If I am
right, Table is declared as void * in header file, the reason is that,
when used later on, it can be casted to any other type of pointers.

It may be you trying to hide implementation details from users
of your code. The outside world uses a void* and your
code (the library) casts it to the right type before use.
This is good. The internal data structure can change
without causing a recompile of the user code.

/* pippo.h */
typedef void* Table_handle;
Table_handle create();
void befunge (Table_handle);

/* pippo.c */
void befunge (Table_handle handle)
{
Table* table = (Table*)handle;
...
}

/* user.c */
int main (void)
{
Table_handle* my_table;
my_table = create();
befunge(my_tabl e);
return 0;
}

The point is I *don't* try and have two differing
definitions of Table.

The implementation of Table in Table.c was defined as pointer to
struct Table, because I need to implement the members of Table.

My professor told us, void * in header indicates a generic type.
He has some sample codes where List was typedef'd void pointer but the
definition was struct List Pointer:

so he had two different types didn't he?

/* Header file List.h*/
#ifndef LIST_H
#define LIST_H

#include "bool.h"

* * * * typedef void * List ;
* * * * typedef void * DataL ;
* * * * typedef void * ListIt ;

* * * * List makeList ( int , void * (*copy)() , void (*free)() ) ;
* * * * void freeList ( List ) ;
* * * * void clearList ( List ) ;

* * * * boolean accessList ( List , DataL , int ) ;
* * * * int lengthList ( List ) ;

* * * * boolean accessHead ( List , DataL ) ;
* * * * boolean insertHead ( List , DataL ) ;
* * * * boolean deleteHead ( List , DataL ) ;

* * */* not all the header file is copied here*/

/* List.c */

#include "bool.h"
#include <stdio.h>
#include <stdlib.h>

#ifndef DATA
#define DATA
typedef void * Data ;
#endif

typedef struct ListNode {
* * * * struct ListNode * next ; * * * */* reference to following ListNode */
* * * * struct ListNode * previous ; * */* reference to preceding ListNode */
* * * * Data dptr ;

} ListNode ;

typedef struct List {
* * * * ListNode * head ; * * * * * * * /* Head end of List * * * * * * */
* * * * ListNode * tail ; * * * * * * * /* Tail end of List * * * * * * */
* * * * int _lengthList ; * * * * * * * /* number ofitems within List **/
* * * * int _sizeData ; * * * * * * * * /* byte size of data to be stored */
* * * * void (*_freeData)( ) ; * * * * */* returns data item to heap * **/
* * * * void * (*_copyData)( ) ; * * * */* copies data item to another **/

} * List ;

arg!!!

don't top post. Please put your reply after the text you are
replying to.

On May 3, 2:32 am, Flash Gordon <[e-mail] te:

Michael.Z wrote, On 03/05/08 08:22:

Anyone who can help:

Given a Table.h file I am writing a Table.c file.
I keep getting the compile error:

previous declaration of Table was here / *conflicting types for

I think the problem was the result of two pieces of code.
First:typedefst ruct Table; */* in Table.c*/

This says that Table is a struct.

Second: struct Table { /*struct definition */ } **Table; */* in
Table.h */

This says it is a pointer to a struct, that is what the * means.

How can I solve the problems?

By not providing different definitions.

Here are the two files

<snip>

>typedefvoid * Table ;

This is not what you said you had and is defining table as yet another type.

<snip>

>typedefstruc t Table{
* * int sizeTable;
* * unsigned sizeData;
* * int (*diff)();
* * unsigned (*hash)();
* * void *(*copy)();
* * void (*free)();
} * Table;

This is what you said. However pointers to void and pointers to structs
are different things for the simple reason that void and struct are
different.

Also hiding pointers behind atypedefis generally considered a bad thing.
--
Flash Gordon-

don't quote sigs (the bit after the "-- ")
--
Nick Keighley

[Ben Bacarisse]

"Michael.Z" <zh**********@g mail.comwrites:

The Table.c was required to be implemented as generic type. If I am
right, Table is declared as void * in header file, the reason is that,
when used later on, it can be casted to any other type of pointers.

The implementation of Table in Table.c was defined as pointer to
struct Table, because I need to implement the members of Table.

My professor told us, void * in header indicates a generic type.
He has some sample codes where List was typedef'd void pointer but the
definition was struct List Pointer:

First, the more common way to "hide the implementation" is simply to
declare your functions as using a 'struct Table *' (as has already
been explained by Flash Gordon).

Secondly, this does not stop you writing generic functions that have a
'void *' parameter. You can pass a 'struct Table *' where a 'void *'
is expected when is important to do so.

There is no obvious advantage to making the Table generic (in that
sense) rather than simply hidden. In fact there is a positive
*disadvantage* to doing that -- you loose all the type-checking. It
is usually much better to stick with hidden (incomplete) struct
pointers right up to the point where you are *forced* to start using
'void *'.

Your professor may have a reason for doing this, but it does seem like
a wise choice from the sample you posted.

--
Ben.

[Michael.Z]

On May 6, 1:21 am, Nick Keighley <nick_keighley_ nos...@hotmail. com>
wrote:

On 6 May, 03:33, "Michael.Z" <zhangqiuy...@g mail.comwrote:

Hi Flash Gordon:
The Table.c was required to be implemented as generic type.

I'm not sure what a "generic type" is and I have been programming
for quite a while.

If I am
right, Table is declared as void * in header file, the reason is that,
when used later on, it can be casted to any other type of pointers.

It may be you trying to hide implementation details from users
of your code. The outside world uses a void* and your
code (the library) casts it to the right type before use.
This is good. The internal data structure can change
without causing a recompile of the user code.

/* pippo.h */typedefvoid* Table_handle;
Table_handle create();
void befunge (Table_handle);

/* pippo.c */
void befunge (Table_handle handle)
{
Table* table = (Table*)handle;
...

}

/* user.c */
int main (void)
{
Table_handle* my_table;
my_table = create();
befunge(my_tabl e);
return 0;

}

The point is I *don't* try and have two differing
definitions of Table.

The implementation of Table in Table.c was defined as pointer to
struct Table, because I need to implement the members of Table.

My professor told us, void * in header indicates a generic type.
He has some sample codes where List wastypedef'd void pointer but the
definition was struct List Pointer:

so he had two different types didn't he?

/* Header file List.h*/
#ifndef LIST_H
#define LIST_H

#include "bool.h"

typedefvoid * List ;
typedefvoid * DataL ;
typedefvoid * ListIt ;

List makeList ( int , void * (*copy)() , void (*free)() ) ;
void freeList ( List ) ;
void clearList ( List ) ;

boolean accessList ( List , DataL , int ) ;
int lengthList ( List ) ;

boolean accessHead ( List , DataL ) ;
boolean insertHead ( List , DataL ) ;
boolean deleteHead ( List , DataL ) ;

/* not all the header file is copied here*/

/* List.c */

#include "bool.h"
#include <stdio.h>
#include <stdlib.h>

#ifndef DATA
#define DATA
typedefvoid * Data ;
#endif

typedefstruct ListNode {
struct ListNode * next ; /* reference to following ListNode */
struct ListNode * previous ; /* reference to preceding ListNode */
Data dptr ;

} ListNode ;

typedefstruct List {
ListNode * head ; /* Head end of List */
ListNode * tail ; /* Tail end of List */
int _lengthList ; /* number of items within List */
int _sizeData ; /* byte size of data to be stored */
void (*_freeData)( ) ; /* returns data item to heap */
void * (*_copyData)( ) ; /* copies data item to another */

} * List ;

arg!!!

don't top post. Please put your reply after the text you are
replying to.

On May 3, 2:32 am, Flash Gordon <[e-mail] te:

Michael.Z wrote, On 03/05/08 08:22:

Anyone who can help:

Given a Table.h file I am writing a Table.c file.
I keep getting the compile error:

previous declaration of Table was here / conflicting types for

I think the problem was the result of two pieces of code.
First:typedefst ruct Table; /* in Table.c*/

This says that Table is a struct.

Second: struct Table { /*struct definition */ } *Table; /* in
Table.h */

This says it is a pointer to a struct, that is what the * means.

How can I solve the problems?

By not providing different definitions.

Here are the two files

<snip>

typedefvoid * Table ;

This is not what you said you had and is defining table as yet another type.

<snip>

typedefstruct Table{
int sizeTable;
unsigned sizeData;
int (*diff)();
unsigned (*hash)();
void *(*copy)();
void (*free)();
} * Table;

This is what you said. However pointers to void and pointers to structs
are different things for the simple reason that void and struct are
different.

Also hiding pointers behind atypedefis generally considered a bad thing.
--
Flash Gordon-

don't quote sigs (the bit after the "-- ")

Hi Nick,

Thanks so much for your reply and your advice for not top posting and
not quote signature, I am new to this, let me know if I need more
further improvements.

Regarding to your post:

>
so he had two different types didn't he?

He did have two different types. Its "void *" in header file while
"struct List *" in List.c;
eg.
/*List.h*/
typedef void *List;

/*List.c*/
typedef struct List{....} *List;

However there was no conflicting type error, the reason is he did not
include file "List.h" in his "List.c".

So I removed #include "Table.h" from my "Table.c", it complied well.
Regards.
Michel Zhang

[CBFalconer]

"Michael.Z" wrote:

Nick Keighley <nick_keighley_ nos...@hotmail. comwrote:

.... snip ...

>

>don't top post. Please put your reply after the text you are
replying to.

.... snip ...

>>
don't quote sigs (the bit after the "-- ")

Thanks so much for your reply and your advice for not top posting
and not quote signature, I am new to this, let me know if I need
more further improvements.

Please also learn to snip. Notice how this has removed anything
not connected with my reply, and marked the snipped areas. Your
answer belongs after (or intermixed with) the quoted material to
which you reply, after snipping all irrelevant material. See the
following links:

<http://www.catb.org/~esr/faqs/smart-questions.html>
<http://www.caliburn.nl/topposting.html >
<http://www.netmeister. org/news/learn2quote.htm l>
<http://cfaj.freeshell. org/google/ (taming google)
<http://members.fortune city.com/nnqweb/ (newusers)

--
[mail]: Chuck F (cbfalconer at maineline dot net)
[page]: <http://cbfalconer.home .att.net>
Try the download section.
** Posted from http://www.teranews.com **

[Flash Gordon]

Michael.Z wrote, On 07/05/08 09:05:

On May 6, 1:21 am, Nick Keighley <nick_keighley_ nos...@hotmail. com>
wrote:

<snip>

Regarding to your post:

>so he had two different types didn't he?

He did have two different types. Its "void *" in header file while
"struct List *" in List.c;
eg.
/*List.h*/
typedef void *List;

/*List.c*/
typedef struct List{....} *List;

In that case what he provided was wrong. No ifs, not buts, it is just
plain wrong. Wrong as in the definition of the language says that it is
wrong.

However there was no conflicting type error,

The error is still there, it is just hidden from the compiler so that it
does not tell you about it. It is no more correct than driver the wrong
way up a one way street at 100mph is legal if you do not get caught. Not
being caught does not make it legal.

the reason is he did not
include file "List.h" in his "List.c".

That, whilst not forbidden by the language, is generally considered to
be bad practice. The reason it is considered to be bad practice is
specifically *because* it hides errors like this.

So I removed #include "Table.h" from my "Table.c", it complied well.

Compiling does not make it correct. If you have a good relationship with
your tutor/lecturer/teacher you should explain to your lecturer that his
code is wrong. If your relationship is not good enough to get away with
that you should ask him why it fails to compile if the header file is
not included (but avoid arguing the point if it will affect your
grades). In either case, you should take any code presented with at
least a pinch of salt, and if he does not understand the problem you
should take the entire course with a whole keg of salt as what you are
being taught is wrong.
--
Flash Gordon

[Michael.Zhang]

[snip: On May 6, 3:32 am, Ben Bacarisse <ben.use...@bsb .me.ukwrote:

"Michael.Z" <zhangqiuy...@g mail.comwrites:

The Table.c was required to be implemented as generic type. If I am
right, Table is declared as void * in header file, the reason is that,
when used later on, it can be casted to any other type of pointers.

The implementation of Table in Table.c was defined as pointer to
struct Table, because I need to implement the members of Table.

]

My professor told us, void * in header indicates a generic type.
He has some sample codes where List wastypedef'd void pointer but the
definition was struct List Pointer:

First, the more common way to "hide the implementation" is simply to
declare your functions as using a 'struct Table *' (as has already
been explained by Flash Gordon).

Secondly, this does not stop you writing generic functions that have a
'void *' parameter. You can pass a 'struct Table *' where a 'void *'
is expected when is important to do so.

I just want to make sure I got you right.You are suggesting:
typedef struct Table{ ...} Table;
Table * makeTable( void* size, void * data);

There is no obvious advantage to making the Table generic (in that
sense) rather than simply hidden. In fact there is a positive
*disadvantage* to doing that -- you loose all the type-checking. It

I don't quit understand this part.
"generic(in that sense)": refers to what I said about my professors
way.
vs
"simply hidden": the above example. Table * makeTable( void* size,
void * data);

is usually much better to stick with hidden (incomplete) struct
pointers right up to the point where you are *forced* to start using
'void *'.

an example of being *forced* would be:

void useTable(*void myTable){
Table * makeTable = (Table *)myTable;

}

if my example is not right, any chance you can give me correct one?

>
Your professor may have a reason for doing this, but it does seem like
a wise choice from the sample you posted.

--
Ben.

"