I'm programming a queue of my own struct data type in Turbo C++ 3.0, I can't build my project because TC presents me an error message of Undefined symbol when it try to linked it.
I have the following queue.h file
#include <stdio.h>
struct pcb{
int *QueueBase;
char id;
int quantum;
};
typedef struct pcb far * ppcb;
typedef struct nodocola far * pnodocola;
struct nodocola{
ppcb a;
pnodocola ant;
};
void insertProcess(ppcb arg1);
ppcb getProcess();
And my file queue.cpp
#include<stdlib.h>
#include<stdio.h>
#include<cola.h>
struct pcb{
int *QueueBase;
char id;
int quantum;
};
typedef struct pcb far * ppcb;
typedef struct nodocola far * pnodocola;
struct nodocola{
ppcb a;
pnodocola ant;
};
pnodocola base = (pnodocola)malloc(sizeof(pnodocola*));
void insertProcess(ppcb arg1){
base->a = arg1;
pnodocola tmp = (pnodocola)malloc(sizeof(pnodocola*));
tmp = base;
base = (pnodocola)malloc(sizeof(pnodocola*));
base->ant = tmp;
}
ppcb getProcess(){
pnodocola tmp = (pnodocola)malloc(sizeof(pnodocola*));
tmp = base->ant;
base = tmp->ant;
return tmp->a;
}
And the file where I include my file queue.h:
#include<queue.h>
#include<dos.h>
#include<stdlib.h>
#include<string.h>
#include<stdio.h>
#include<conio.h>
#include<iostream.h>
void interrupt myTimer(...);
void interrupt (*prev)(...);
ppcb actual = (ppcb)malloc(sizeof(ppcb*));
int ticks;
const quantum = 4;
void main()
{
clrscr();
prev=getvect(8);
setvect(8,myTimer);
getch();
disable();
setvect(8,prev);
enable();
}
void interrupt myTimer(...)
{
(*prev)();
}
void init(...)
{
actual->id='A';
actual->quantum = quantum;
insertProcess(actual);
}
Error: Undefined symbol insertProcess(ppcb far)*
I'm working in a virtual machine with Windows XP 32 bits.
Edit: Sorry I have a mistake, I rename my file from cola.h to queue.h when I write the question, but the #include is correctly and the error is present.
And are you actually linking with the object file produced by queue.cpp? It's not enough to just include the header file in your main code, you have to link both the main code and the queue code when you create the executable.
And, as an aside, why are you using such an archaic C implementation when far better, far more modern and just-as-cheap options are available?
In order to make Turbo C compile multiple source files, I think you have to create a project and then add the C files to that project. It will then know it has to compile and link all those source files in the project.
If you just have a single source file (no project), it treats it as a project with just that file.
You say you include "queue.h" but I can't see a #include "queue.h" anywhere in the relevant file.
Related
So I defined a struct in module.c and typedef'd it in module.h, as someone in this thread told to do (How do I refer to a typedef in a header file?). But when I try to compile the project I get lots of errors, such as:
error: variable 'messi' has initializer but incomplete type
error: unknown field 'id' specified in initializer
error: storage size of 'messi' isn't known
But if I put all my code in the same file, it compiles and runs just fine. I'm kinda new to C and this is making me crazy because I can't find a solution anywhere. Searching the errors by themselves I find people having problems from typos and from using the struct after they typedef'd, which doesn't seem to be the case for me.
My code is something like this:
module.c
#include "module.h"
struct s_player{
int id;
char name[256];
struct s_player *next;
};
module.h
typedef struct s_player player;
main.c
#include "module.h"
player messi = {.id = 158023, .name = "Lionel Andres Messi Cuccittini", .next = NULL};
Move the declarations (struct, typedef) to your header file module.h:
struct s_player{
int id;
char name[256];
struct s_player *next;
};
typedef struct s_player player;
then in your main.c file:
#include <stdio.h>
#include "module.h"
int main() {
player messi = {.id = 158023, .name = "Lionel Andres Messi Cuccittini", .next = NULL};
printf("%s", messi.name);
}
i'm doing a simple project in C in which, for the moment, i use two structs: Player and Card.
I have created the 2 struct in different header files, because functions in Player use Card, but also other elements that I haven't already done.
When I try to use getId() in Player, the VSCode's compiler says:
reference to external symbol _getId not resolved in _discardCard()
card.h code is:
#include <stdbool.h>
typedef struct card{
int id;
bool black;
int numElems;
char* text[3];
}card;
card* initCard(int id,bool black,char* text[],int numElems)
int getId(card* c);
card.c code is:
#include "carta.h"
#include<stdio.h>
#include <stdbool.h>
#include <stdlib.h>
...
int getId(carta* c){
return c->id;
}
Instead the code for Player.h is:
#include "card.h"
#define CARDSMAX 5
typedef struct{
bool master;
int id;
int points;
char* nickname;
card* cards[CARDSMAX];
int NumCards;
}player;
... //other functions
card* discardCard(int id,player* g);
The code for Player.c is:
#include "player.h"
#include <stdio.h>
#include <stdlib.h>
player* initPlayer(char* nickname,int id){
player* g=(player*) malloc(sizeof (player));
g->id=id;
g->nickname=nickname;
g->master=false;
g->points=0;
g->NumCards=0;
for(int i=0;i<CARDSMAX;i++){
g->cards[i]=(card*)malloc(sizeof(card));
}
return g;
}
....
card* DiscardCard(int id,player* g){
for(int i=0;i<CARDSMAX;i++){
card* c=g->cards[i];
if(getId(c)==id){
card* e= g->cards[i];
g->cards[i]=NULL;
g->NumCards--;
return e;
}
}
return NULL;
}
Can someone help me? (If you see some inconsistency in the code, it'is because i tried a fast translation from my language)
So, as suggested , the problem was that in Windows' compiler, when you use struct that use function defined in other structs,it is required to pass the .obj file during the compilation .
For doing this you need to compile every .c file that is used by others singulary and then link the .obj file created in this fase.
So in my case the first step is to compile:
cl card.c
that create a card.obj (the Windows' compiler could show you a message that says something like:"The start point is not indicated" if you don't use a main in this first file, don't worry and carry on with this procedure) and then I compile:
cl player.c /link card.obj
So in this way you pass the compiled object in which it's provided the implementation of all the function in the struct.
Okay, I have a main source called main.c, a header file called test.h, and another class called handBeraknare.c.
Im trying to make my code a bit more readable by transfeering some of my methods to the class handBeraknare.c.
So in main.c i have a struct that looks like this:
typedef struct kort{
int draget;
char farg;
int nummer;
struct kort *next;
}kort; `
In main.c i create a couple of these using kort k=(kort*)malloc(sizeof(kort)); and put them into an array. What im trying to achive is to send this array of kort to a function in handBeraknare.c but I get some sort of weird error "in file included from handBeraknare.c".
Im gussing this has to do with the headerfile now knowing what "kort" is (my struct). Anyway, here's some of the code:
// in test.h
int beraknaFarg(kort kortHand[]);
// in handBeraknare.c
#include <stdio.h>
#include "test.h"
int beraknaFarg(kort kortHand[]){
char c = kortHand[0].farg;
int i;
for (i=1;i<5;i++){
if (kortHand[i].farg!=c){
printf("inte färg");
system("pause");
//Spelaren har inte färg. Retunera 0
return 0;
}
}
//Spelaren har färg. Retunera 1
printf("!!!!färg");
system("pause");
return 1;
}
//part of the main class. Calling function test()
// which calls the method beraknaHand which exists in handBeraknare.c
#include "test.h"
...
int main(int argc, char *argv[])
{
test();
}
// the testfunction in my mainclass
void test(){
char farg[4]={'S','K','R','J'};
int nummer[14]={0,2,3,4,5,6,7,8,9,10,11,12,13,14};
kort kortArray[52];
kort kortHand[5];
kort *k;
k=(kort*)malloc(sizeof(kort));
k->farg='s';
k->nummer=5;
kortHand[0]=*k;
k->farg='s';
k->nummer=11;
kortHand[1]=*k;
k->farg='s';
k->nummer=12;
kortHand[2]=*k;
k->farg='s';
k->nummer=11;
kortHand[3]=*k;
k->farg='s';
k->nummer=9;
kortHand[4]=*k;
beraknaFarg(kortHand);
Make test.h to read
typedef struct kort{
int draget;
char farg;
int nummer;
struct kort *next;
} kort;
int beraknaFarg(kort kortHand[]);
and remove the typedef from main.c
You need to define the typedef in the header file, and then include the header file in the C file you want it to use it.
in addition , because it is typedef defintion and not declaration , you need to define it in the C file.
I.E
h file:
typedef strcut
{
int a;
....
}t_struct_type;
c file:
t_struct_type struct_var;
if you want to use struct_var in more than one c file , you need to add the extern keyword in the h file. like this : extern t_strcut_type struct_var
How do you access a struct say struct common, that is defined in a header file, in a .c file? We'll include the header file in the .c file and then can we directly use
struct common C;?
header file-new_algo.h
#ifndef NEW_ALGO_H_
#define NEW_ALGO_H_
#endif /* NEW_ALGO_H_ */
struct common{
float count;
//other variables
};
main.c
#include "new_algo.h"
int main()
{
typedef struct common myStruct;
myStruct* S;
S->count = 0;//when I do this segmentation fault occurs
//this is the error I get in eclipse
/* Thread [1] 0 (Suspended : Signal : SIGSEGV:Segmentation fault)
main() at E:/Namratha//trial/.settings/..\\src\\main.c:44 0x401443*/
}
Hey, the fault error is not resulted from access control.
Before use struct varible, you should malloc space for it like
myStrcut *s = (myStrcut *)malloc(sizeof(myStruct))
then assign:
s->count = 0
Please have a try.
Yes, it's correct. Just include the header in the source file and create the instance for the struct.
header.h
struct common
{
// ...
};
.c
#include "header.h"
struct common C ;
File api.h
#include <stdio.h>
#ifndef API
#define API
struct trytag;
typedef struct trytag try;
void trial (try *);
#endif
File core.h
#ifndef CORE
#define CORE
struct trytag
{
int a;
int b;
};
#endif
File func.c
#include "api.h"
#include "core.h"
void trial (try *tryvar)
{
tryvar->a = 1;
tryvar->b = 2;
}
File main.c
#include "api.h"
int main ()
{
try s_tryvar;
trial(&s_tryvar);
printf("a = %d\nb = %d\n", s_tryvar.a, s_tryvar.b);
}
When I compile, I get:
main.c:5: error: storage size of ‘s_tryvar’ isn’t known
If I include core.h in main.c this error doesn't come as try is defined in core.h. But I want the structure try to be hidden to main.c — it should not know the members of try structure. What am I missing?
I don't think what you're trying to do is possible. The compiler needs to know how big a try structure is to compile main.c. If you really want it to be opaque, make a generic pointer type, and instead of declaring the variable directly in main(), make alloc_try() and free_try() functions to handle the creation and deletion.
Something like this:
api.h:
#ifndef API
#define API
struct trytag;
typedef struct trytag try;
try *alloc_try(void);
void free_try(try *);
int try_a(try *);
int try_b(try *);
void trial (try *);
#endif
core.h:
#ifndef CORE
#define CORE
struct trytag
{
int a;
int b;
};
#endif
func.c:
#include "api.h"
#include "core.h"
#include <stdlib.h>
try *alloc_try(void)
{
return malloc(sizeof(struct trytag));
}
void free_try(try *t)
{
free(t);
}
int try_a(try *t)
{
return t->a;
}
int try_b(try *t)
{
return t->b;
}
void trial(try *t)
{
t->a = 1;
t->b = 2;
}
main.c:
#include <stdio.h>
#include "api.h"
int main()
{
try *s_tryvar = alloc_try();
trial(s_tryvar);
printf("a = %d\nb = %d\n", try_a(s_tryvar), try_b(s_tryvar));
free_try(s_tryvar);
}
Think how the opaque FILE structure works in C. You only work with pointers, and you need a function like fopen() to create an instance, and a function like fclose() to dispose of it.
The problem is in main.c, the compiler hasn't seen the definition of struct try. Because of that, the compiler is limited to using pointers to struct try.
What you want to do is add two new functions to your API:
try *create_try();
void *destroy_try(try *t);
These functions will call malloc and free respectively.
If you don't want to limit your structure to only being allowed on the heap, you are going to have to give up on making it opaque.
There is a way to do something that technically is not exactly what you are asking for, but should serve the same purpose of keeping your structure opaque while supporting non-heap allocation.
in api.h, you state an opaque structure as follows:
struct trytag_opaque
{
char data[sizeof(int)*2];
};
if you wanted to be more opaque than that, you could calculate the maximum size of the structure required across any supported platform, and use:
struct trytag_opaque
{
char data[MAX_TRYTAG_SIZE];
};
Then your api.h function declarations would look like:
int try_a(struct trytag_opaque *t)
and your function code would look like:
int try_a(struct trytag_opaque *t_opaque) {
trytag *t = (trytag *)t_opaque;
...
}
and your main.c would look like:
#include "api.h"
int main() {
struct trytag_opaque t;
...
try_a(&t);
...
}