I have seen many questions on this topic, but couldn't take much sense from them and couldn't compare it to my code. I'm not sure what I'm doing wrong, but it appears as a warning on Eclipse, and I think it might be what's making my function behave differently than it should.
The comments and variables are in portuguese, so if you need me to translate any part of it, or to tell you what each function should do, just tell me.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "grafo.h"
typedef struct _relemento
{
/** string armazenada */
char *nome;
int x, y, id;
struct _elemento *proximo;
} robot_lista;
typedef struct
{
robot_lista *raiz;
int tamanho;
} listarobots;
typedef struct _elemento
{
/** string armazenada */
int x;
int y;
int v;
struct _elemento *proximo;
} elemento_lista;
typedef struct
{
elemento_lista *raiz;
int tamanho;
} lista;
listarobots* listarobots_nova()
{
/* cria lista */
listarobots *lst = (listarobots*) malloc(sizeof(listarobots));
if(lst == NULL)
return NULL;
/* lista esta' vazia */
lst->raiz = NULL;
lst->tamanho = 0;
return lst;
}
robot_lista* novorobot_str(const char* valor, int x, int y, int id)
{
/* aloca memoria para a estrutura lista */
robot_lista *item = (robot_lista *) malloc(sizeof(robot_lista));
if(item == NULL)
return NULL;
/* aloca memoria para string */
item->nome = (char *) malloc((strlen(valor)+1)*sizeof(char));
if(item->nome == NULL)
{
free(item);
return NULL;
}
/* copia valor */
strcpy(item->nome, valor);
item->x=x;
item->y=y;
item->id=id;
/* item ainda nao tem proximo */
item->proximo = NULL;
return item;
}
int listarobots_insere(listarobots *lst, const char* valor, int x, int y,int id)
{
robot_lista *curr = NULL, *temp;
if (lst == NULL)
return -1;
temp = lst->raiz;
/* cria novo item */
curr = novorobot_str(valor, x, y, id);
if (curr == NULL)
return -1;
lst->tamanho++;
curr->proximo = temp;
lst->raiz = curr;
return 1;
}
int listarobot_pesquisa(listarobots *lst, const char* str, int* x, int* y, int *id)
{
int i=0;
robot_lista *aux;
if(lst == NULL)
return -1;
/* pesquisa sequencial */
for (aux = lst->raiz; aux != NULL; aux = aux->proximo, i++)
{
if (strcmp((aux->nome), str) == 0)
{
*x= aux->x;
*y= aux->y;
*id= aux->id;
return i;
}
}
return -1;
}
int listarobot_atribui(listarobots *lst, int pos, int x, int y)
{
int i=0;
robot_lista *aux;
if (lst == NULL || pos < 0)
return -1;
aux = lst->raiz;
/* procura item na posicao pos */
for (i = 0; i < pos && aux != NULL; i++)
aux = aux->proximo;
/* se aux e' NULL entao nao existe posicao pos */
if (aux == NULL)
return -1;
aux->x=x;
aux->y=y;
return pos;
}
lista* lista_nova()
{
/* cria lista */
lista *lst = (lista*) malloc(sizeof(lista));
if(lst == NULL)
return NULL;
/* lista esta' vazia */
lst->raiz = NULL;
lst->tamanho = 0;
return lst;
}
elemento_lista* novo_str(int x, int y, int v)
{
/* aloca memoria para a estrutura lista */
elemento_lista *item = (elemento_lista *) malloc(sizeof(elemento_lista));
if(item == NULL)
return NULL;
item->v=v;
item->x=x;
item->y=y;
/* item ainda nao tem proximo */
item->proximo = NULL;
return item;
}
int lista_insere(lista *lst, int x, int y, int v)
{
elemento_lista *curr = NULL, *temp;
if (lst == NULL)
return -1;
temp = lst->raiz;
/* cria novo item */
curr = novo_str(x,y,v);
if (curr == NULL)
return -1;
lst->tamanho++;
curr->proximo = temp;
lst->raiz = curr;
return v;
}
int lista_pesquisa(lista *lst, int x, int y)
{
int i=0;
elemento_lista *aux;
if(lst == NULL)
return -1;
/* pesquisa sequencial */
for (aux = lst->raiz; aux != NULL; aux = aux->proximo, i++)
{
if ((aux->x==x) && (aux->y==y))
{
return aux->v;
}
}
return -1;
}
int lista_xy (lista *lst, int v, int *x , int* y)
{
int i=0;
elemento_lista *aux;
if(lst == NULL)
return -1;
/* pesquisa sequencial */
for (aux = lst->raiz; aux != NULL; aux = aux->proximo, i++)
{
if ((aux->v==v))
{
*x=aux->x;
*y=aux->y;
return 1;
}
}
return -1;
}
void leitura(int *tamx,int *tamy,int *xminfinal, int* yminfinal, int *wx, int *wy, int *fimx, int *fimy, FILE * fp, grafo *robots, lista *celulas, listarobots *posicoes)
{
int naofaznada,tamanho=0, i, x, y, xmax, xmin, ymax, ymin, v=1,dest,poslst, origem,id=0;
char nome[16], aux;
xmax=xmin=ymax=ymin=0;
celulas=lista_nova();
lista_insere(celulas, 0,0,0);
fp = fopen("input.txt", "r");
robots = grafo_novo(tamanho,NAODIRECIONADO);
posicoes=listarobots_nova();
fscanf( fp, " %c", &aux);
while (aux!=EOF)
{
for (i=0;aux!= ',';i++)
{
nome[i]=aux;
nome[i+1]='\0';
fscanf(fp, " %c", &aux);
}
fscanf(fp, " %c", &aux);
poslst=listarobot_pesquisa(posicoes, nome, &x, &y, &naofaznada);
if(poslst==-1)
{
if(aux=='D')
{
x=0;
y=-1;
}
if(aux=='U')
{
x=0;
y=1;
}
if(aux=='L')
{
x=-1;
y=0;
}
if(aux=='R')
{
x=1;
y=0;
}
listarobots_insere(posicoes, nome, x, y, id);
id++;
origem=0;
if(x>xmax) xmax=x;
if(x<xmin) xmin=x;
if(y>ymax) ymax=y;
if(y<ymin) ymin=y;
if(lista_pesquisa(celulas, x, y)==-1)
{
lista_insere(celulas, x, y, v);
dest=v;
v++;
grafo_adiciona(robots, 0, dest);
if(lista_pesquisa(celulas, (x+1),y)!=-1) grafo_adiciona(robots, dest, lista_pesquisa(celulas, (x+1), y));
if(lista_pesquisa(celulas, (x-1),y)!=-1) grafo_adiciona(robots, dest, lista_pesquisa(celulas, (x-1), y));
if(lista_pesquisa(celulas, x,(y+1))!=-1) grafo_adiciona(robots, dest, lista_pesquisa(celulas, x, (y+1)));
if(lista_pesquisa(celulas, x,(y-1))!=-1) grafo_adiciona(robots, dest, lista_pesquisa(celulas, x, (y-1)));
}
}
else
{
origem=lista_pesquisa(celulas,x, y);
if(aux=='D')
{
y=y-1;
}
if(aux=='U')
{
y=y+1;
}
if(aux=='L')
{
x=x-1;
}
if(aux=='R')
{
x=x+1;
}
listarobot_atribui(posicoes, poslst, x, y);
}
if(x>xmax) xmax=x;
if(x<xmin) xmin=x;
if(y>ymax) ymax=y;
if(y<ymin) ymin=y;
if(lista_pesquisa(celulas, x, y)==-1)
{
lista_insere(celulas, x, y, v);
dest=v;
v++;
grafo_adiciona(robots, origem, dest);
if(lista_pesquisa(celulas, (x+1),y)!=-1) grafo_adiciona(robots, dest, lista_pesquisa(celulas, (x+1), y));
if(lista_pesquisa(celulas, (x-1),y)!=-1) grafo_adiciona(robots, dest, lista_pesquisa(celulas, (x-1), y));
if(lista_pesquisa(celulas, x,(y+1))!=-1) grafo_adiciona(robots, dest, lista_pesquisa(celulas, x, (y+1)));
if(lista_pesquisa(celulas, x,(y-1))!=-1) grafo_adiciona(robots, dest, lista_pesquisa(celulas, x, (y-1)));
}
if(fscanf(fp, " %c", &aux)==EOF) break;
if(aux=='?')
{
*wx=x;
*wy=y;
if(fscanf(fp, " %c", &aux)==EOF) break;
}
if(aux=='!')
{
*fimx=x;
*fimy=y;
if(fscanf(fp, " %c", &aux)==EOF) break;
}
}
*tamx= xmax-xmin+1;
*tamy= ymax-ymin +1;
*xminfinal=xmin;
*yminfinal=ymin;
return ;
}
void mapeamento(FILE * out, int x, int y, int ymin, int xmin, int wx, int wy, int fimx, int fimy, lista* celulas )
{
int xatual, yatual;
for(yatual=ymin+ y-1; yatual!=ymin-1;yatual--)
{
for(xatual=xmin; xatual!=xmin+x; xatual++)
{
if((xatual==0) && (yatual==0)) fprintf(out," e ");
else if((xatual==wx)&&(yatual==wy)) fprintf(out, " w ");
else if((xatual==fimx)&&(yatual==fimy)) fprintf(out, " s ");
else if(lista_pesquisa(celulas, x, y)==-1) fprintf(out, " * ");
else if(lista_pesquisa(celulas, x, y)!=-1)fprintf(out, " . ");
if(xatual==fimx) fprintf(out, "\n");
}
}
return;
}
void caminhos(int wx, int wy, int fimx, int fimy, lista* celulas, FILE *fp, FILE *out, grafo *robots, listarobots* posicoes)
{
int restantes,nfnx,nfny,i,id,is,antx,anty,novox,novoy,tamanhocaminho1,tamanhocaminho2, *caminho1, *caminho2, *posrobots;
char *caminho,nome[16], aux;
caminho1=grafo_bfs(robots, 0, lista_pesquisa(celulas, wx, wy), &tamanhocaminho1);
caminho2=grafo_bfs(robots, lista_pesquisa(celulas, wx, wy), lista_pesquisa(celulas, fimx, fimy), &tamanhocaminho2);
caminho= malloc((tamanhocaminho1+tamanhocaminho2)*sizeof(char));
antx=0;
anty=0;
is=0;
for(i=1; i<tamanhocaminho1; i++, is++)
{
lista_xy(celulas, caminho1[i], &novox, &novoy);
if((novox-antx)==1) caminho[is]= 'R';
else if((novox-antx)==-1) caminho[is]= 'L';
else if((novoy-anty)==-1) caminho[is]= 'D';
else if((novoy-anty)==1) caminho[is]= 'U';
antx=novox;
anty=novoy;
}
for(i=1; i<tamanhocaminho2; i++, is++)
{
lista_xy(celulas, caminho1[i], &novox, &novoy);
if((novox-antx)==1) caminho[is]= 'R';
else if((novox-antx)==-1) caminho[is]= 'L';
else if((novoy-anty)==-1) caminho[is]= 'D';
else if((novoy-anty)==1) caminho[is]= 'U';
antx=novox;
anty=novoy;
}
caminho[is]='\0';
fprintf(out, "\n\n%s\n", caminho);
free(caminho1);
free(caminho2);
fclose(fp);
fp=fopen("input.txt", "r");
restantes=posicoes->tamanho;
posrobots=calloc (posicoes->tamanho, sizeof(int));
fscanf(fp, " %c", &aux);
while (aux!=EOF)
{
for (i=0;aux!= ',';i++)
{
nome[i]=aux;
nome[i+1]='\0';
fscanf(fp, " %c", &aux);
}
fscanf(fp, " %c", &aux);
listarobot_pesquisa(posicoes, nome, &nfnx, &nfny, &id);
if(posrobots[id]==-1) nfnx=1;
else if(caminho[posrobots[id]]==aux) posrobots[id]++;
else
{
posrobots[id]=-1;
restantes--;
}
if(posrobots[id]==is) fprintf(out, "%s\n", nome);
fscanf(fp, " %c", &aux);
if(aux=='?')
{
fscanf(fp, " %c", &aux);
}
if(aux=='!')
{
fscanf(fp, " %c", &aux);
}
}
if(restantes==0) fprintf(out, "0\n");
}
void output()
{
}
int main()
{
FILE *fp, *out;
grafo *robots;
lista *celulas;
listarobots *posicoes;
celulas=(lista * )malloc(sizeof(lista));
robots=(grafo * )malloc(sizeof(grafo));
posicoes=(listarobots * )malloc(sizeof(listarobots));
fp=(FILE * )malloc(sizeof(FILE));
out=(FILE * )malloc(sizeof(FILE));
int x,y,xmin, ymin,wx,wy,fimx,fimy;
out=fopen("output.txt", "w");
leitura(&x, &y, &xmin, &ymin,&wx, &wy, &fimx, &fimy, fp, robots, celulas, posicoes);
fprintf(out,"largura:%d, altura:%d\n", x, y );
mapeamento(out, x, y, ymin, xmin, wx, wy, fimx, fimy, celulas);
//caminhos(wx, wy,fimx, fimy,celulas, fp, out, robots, posicoes);
return 0;
}
the extra includes dont make a difference, I've checked and the errors are on this block of code, but just in case, I'll post here the code for the include "grafo.h"
#include <stdio.h>
#include <stdlib.h>
#include "grafo.h"
/* cria no da lista de adjacencias */
lista_no* cria_no(int v)
{
lista_no* novo = (lista_no*)malloc(sizeof(lista_no));
if(!novo)
return NULL;
novo->vertice = v;
novo->proximo = NULL;
return novo;
}
/* cria grafo com n vertices */
grafo* grafo_novo(int n, tipo_grafo tipo)
{
grafo* g = (grafo*)malloc(sizeof(grafo));
lista_no novo;
if(g == NULL)
return NULL;
g->tamanho = 1;
g->tipo = tipo;
/* cria array de listas de adjacencias */
g->adjacencias = (lista_adj*)calloc(n, sizeof(lista_adj));
if(g->adjacencias == NULL)
{
free(g);
return NULL;
}
g->adjacencias[0].inicio=NULL;
return g;
}
/* apaga grafo e liberta memoria */
void grafo_apaga(grafo* g)
{
if(g == NULL)
return;
if(g->adjacencias != NULL)
{
int v;
for (v = 0; v < g->tamanho; v++)
{
while (g->adjacencias[v].inicio)
{
lista_no* aux = g->adjacencias[v].inicio;
g->adjacencias[v].inicio = g->adjacencias[v].inicio->proximo;
free(aux);
}
}
free(g->adjacencias);
}
free(g);
}
/* adiciona uma aresta ao grafo*/
void grafo_adiciona(grafo *g, int origem, int dest)
{
lista_no* novo,*aux,*ant;
if (g == NULL || grafo_existe(g, origem, dest))
return;
/* adiciona uma aresta de origem para dest na lista de adjacencias */
novo = cria_no(dest);
novo->proximo = NULL;
g->adjacencias = (lista_adj*)realloc(g->adjacencias, (g->tamanho+1)*sizeof(lista_adj));
g->adjacencias[dest].inicio=NULL;
g->tamanho++;
ant= aux =g->adjacencias[origem].inicio;
if(ant==NULL) g->adjacencias[origem].inicio=novo;
else
{
aux=ant->proximo;
while(aux!=NULL)
{
ant=aux;
aux=ant->proximo;
}
ant->proximo=novo;
}
g->adjacencias[origem].tamanho++;
if(g->tipo == NAODIRECIONADO)
{
/* adiciona tambem aresta de dest para origem */
novo = cria_no(origem);
novo->proximo = NULL;
ant= aux =g->adjacencias[dest].inicio;
if(ant==NULL) g->adjacencias[dest].inicio=novo;
else
{
aux=ant->proximo;
while(aux!=NULL)
{
ant=aux;
aux=ant->proximo;
}
ant->proximo=novo;
}
g->adjacencias[dest].tamanho++;
}
}
/* remove uma aresta do grafo*/
void grafo_remove(grafo *g, int origem, int dest)
{
lista_no *aux, *prev;
if (g == NULL || g->adjacencias[origem].inicio == NULL)
return;
aux = g->adjacencias[origem].inicio;
/* caso especial: primeiro no' da lista */
if(aux->vertice == dest)
{
g->adjacencias[origem].inicio = aux->proximo;
free(aux);
}
else
{
prev = aux;
aux = aux->proximo;
while(aux != NULL)
{
if(aux->vertice == dest)
{
prev->proximo = aux->proximo;
free(aux);
break;
}
prev = aux;
aux = aux->proximo;
}
}
if(g->tipo == NAODIRECIONADO)
{
/* remove tambem aresta de dest para origem */
/* caso especial: primeiro no' da lista */
aux = g->adjacencias[dest].inicio;
if(aux->vertice == origem)
{
g->adjacencias[dest].inicio = aux->proximo;
free(aux);
}
else
{
prev = aux;
aux = aux->proximo;
while(aux != NULL)
{
if(aux->vertice == origem)
{
prev->proximo = aux->proximo;
free(aux);
break;
}
prev = aux;
aux = aux->proximo;
}
}
}
}
/* verifica se existe uma aresta entre os vertices origem e dest */
int grafo_existe(grafo *g, int origem, int dest)
{
if (g == NULL)
return 0;
lista_no* aux = g->adjacencias[origem].inicio;
while (aux)
{
if(aux->vertice == dest)
return 1;
aux = aux->proximo;
}
return 0;
}
/* imprime as listas de adjacencias do grafo */
void grafo_imprime(grafo* g)
{
int i;
for (i = 0; i < g->tamanho; i++)
{
lista_no* aux = g->adjacencias[i].inicio;
printf("%d: ", i);
if(aux)
{
printf("%d", aux->vertice);
aux = aux->proximo;
while (aux)
{
printf("->%d", aux->vertice);
aux = aux->proximo;
}
}
printf("\n");
}
}
int dfs_helper(grafo *g, int inicio, int fim, int profundidade, int *visitados)
{
int i, d;
if(visitados[inicio])
return 0;
visitados[inicio] = profundidade;
if(inicio == fim)
return profundidade;
for(i=0; i < g->tamanho; i++)
{
if(grafo_existe(g, inicio, i))
{
d = dfs_helper(g, i, fim, profundidade + 1, visitados);
if(d)
return d;
}
}
visitados[inicio] = 0;
return 0;
}
/* retorna caminho entre origem e dest usando depth-first search (DFS)
n guarda o tamanho do caminho
nao garante caminho mais curto */
int* grafo_dfs(grafo *g, int inicio, int fim, int *n)
{
int *visitados, *caminho;
int profundidade, i, ret_i;
if(g==NULL)
return 0;
visitados = calloc(g->tamanho, sizeof(int));
profundidade = dfs_helper(g, inicio, fim, 1, visitados);
if(profundidade == 0)
{
free(visitados);
*n=0;
return NULL;
}
/* reconstrucao do caminho */
caminho = calloc(profundidade, sizeof(int));
for (ret_i = 0; ret_i < profundidade; ret_i++)
for (i = 0; i< g->tamanho; i++)
if(visitados[i] == ret_i + 1)
{
caminho[ret_i] = i;
break;
}
*n = profundidade;
free(visitados);
return caminho;
}
/* retorna caminho entre origem e dest usando breadth-first search (BFS)
n guarda o tamanho do caminho
garante caminho mais curto */
int* grafo_bfs(grafo *g, int inicio, int fim, int *n)
{
int *caminho, *visitados, *fila;
int profundidade, i, j, fila_inicio = 0, fila_fim=0;
if(g==NULL)
return 0;
visitados = calloc(g->tamanho, sizeof(int));
fila = calloc(g->tamanho, sizeof(int));
for(i = 0; i < g->tamanho; i++)
visitados[i] = -1;
visitados[inicio] = inicio;
fila[fila_fim++] = inicio;
while(fila_inicio != fila_fim)
{
i = fila[fila_inicio];
fila_inicio = (fila_inicio + 1) % g->tamanho;
for(j = 0; j < g->tamanho; j++)
if(grafo_existe(g, i, j) && visitados[j] == -1)
{
visitados[j] = i;
fila[fila_fim] = j;
fila_fim = (fila_fim + 1) % g->tamanho;
}
}
/* reconstrucao do caminho */
profundidade = 0;
if(visitados[fim] >= 0)
{
int tmp = fim;
profundidade = 1;
while(visitados[tmp] != tmp)
{
profundidade++;
tmp = visitados[tmp];
}
caminho = malloc(profundidade * sizeof(int));
tmp = fim;
i = 0;
while(i++ < profundidade)
{
caminho[profundidade - i] = tmp;
tmp = visitados[tmp];
}
}
free(fila);
free(visitados);
*n=profundidade;
return caminho;
}
And the warnings are:
Description Resource Path Location Type
assignment from incompatible pointer type [enabled by default] trabalho.c /trabalho/src line 110 C/C++ Problem
assignment from incompatible pointer type [enabled by default] trabalho.c /trabalho/src line 135 C/C++ Problem
assignment from incompatible pointer type [enabled by default] trabalho.c /trabalho/src line 95 C/C++ Problem
I appreciate any and all the help you can offer. I am still pretty new at programming and this warnings are completely messing with my mind.
It looks like you're assigning proximo (which are pointers to _elemento) to variables that are pointers to robot_lista.
I am a noob in c, and i have this code that doesnt work properly because some bad memory allcoation i make for a char** pointer. Could you please help? Thx a lot in advance.
Code:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct node_t {
struct tuple_t *tuple; //Entrada na lista
struct node_t *next; //o node seguinte da lista
};
struct tuple_t {
long timestamp; /* instante de criacao do tuplo*/
int n_fields; /* numero de campos deste tuplo */
char **fields; /* array com campos do tuplo */
/* 4 + 4 + 4 bytes?? */
};
char ** split_str(char [], char **, const char *);
struct node_t *node_create(void *node_data){
struct node_t *node = NULL;
node = (struct node_t *)malloc(sizeof(struct node_t));
if(!node){
printf("Erro ao criar um node!\n");
return NULL;
}
node->tuple = (struct tuple_t *)malloc(sizeof(struct tuple_t));
if(!node->tuple){printf("Erro ao criar o node->tuple\n"); free(node); return NULL;}
node->tuple->fields = (char ** )malloc(strlen((char *) node_data) * sizeof(char *));
if(!node->tuple->fields){ printf("Erro ao criar o node->tuple->node_fields\n"); free(node->tuple); free(node); return NULL; }
char **array;
const char *sep=" ";
char *s = (char *)node_data;
char arr[strlen(s)];
int i = 0;
while(arr[i++]=s[i]);
array = split_str(arr,array, sep);
i = 0;
while(array[i]){
node->tuple->fields[i] = (char *)malloc((strlen(array[i])) * sizeof(char));
if(!node->tuple->fields[i]){
printf("Erro ao alocar memoria em node_create() para node->tuple->fields[i]\n");
return NULL;
}
node->tuple->fields[i] = array[i];
// printf("array[i]=%s\n",array[i]);
// printf("node->tuple->fields[i]=%s\n",node->tuple->fields[i]);
i++;
}
node->tuple->n_fields = i;
node->tuple->timestamp = 0L;
node->next = NULL;
return node;
}
char** split_str(char writablestring[],char **array, const char *sep ){
array = malloc(strlen(writablestring) + 1);
if(! array){printf("Erro ao alocar memoria para o array em split\n"); return NULL;}
char *token = strtok(writablestring, sep);
int i=0;
while(token != NULL)
{
array[i] = malloc(strlen(token)+1);
if(!array[i])
return NULL;
array[i] = token;
token = strtok(NULL, " ");
i++;
}
return array;
}
int main(int argc, char** argv)
{
void * n_data = "hello 123 ploc";
struct node_t * node = node_create(n_data);
printf("node->num_fields=%d\n", node->tuple->n_fields);
int i=0;
while( node->tuple->fields[i] ){
printf("node->tuple->fields[%d]=%s\n",i,node->tuple->fields[i]);
i++;
}
return 0;
}
End code.
Your split_str() function returns pointers into writablestring, which is the array arr in node_create(). You then copy these pointers into node->tuple->fields[i] - but the arr array won't exist after the node_create() function exits - so those pointers will no longer be valid. Instead, you need to copy the returned string into the memory that you have allocated (this also shows how you can use a for() loop in place of your while(), and you also need to free the memory that was allocated in split_str()):
for (i = 0; array[i]; i++) {
node->tuple->fields[i] = malloc(strlen(array[i]) + 1);
if (!node->tuple->fields[i]){
printf("Erro ao alocar memoria em node_create() para node->tuple->fields[i]\n");
return NULL;
}
strcpy(node->tuple->fields[i], array[i]);
}
free(array);
Additionally, your code assumes that the array returned by split_str() will be terminated by a NULL, but the function does not ensure this. The function has numerous other problems (incorrect size passed to malloc(), memory leak caused by unnecessary malloc()) - so you need to fix it, too:
char **split_str(char writablestring[], const char *sep)
{
char **array = malloc(strlen(writablestring) * sizeof array[0]);
if(!array) {
printf("Erro ao alocar memoria para o array em split\n");
return NULL;
}
char *token = strtok(writablestring, sep);
int i;
for (i = 0; (array[i] = token) != NULL; i++) {
token = strtok(NULL, " ");
}
return array;
}
(Note that array does not need to be passed as a parameter - it's being immediately overwritten anyway, so I turned it into a local variable).
Once you've done this, you might notice that there's really no reason to allocate array in split_str(), only to copy its contents to node->tuple->fields and then free it. You might as well pass the array node->tuple->fields to split_str() and have it write directly into it. It could then return the number of strings allocated - that would look like:
int split_str(char [], char **, const char *);
struct node_t *node_create(void *node_data)
{
struct node_t *node = NULL;
char *s = node_data;
size_t slen = strlen(s);
node = malloc(sizeof *node);
if (!node) {
printf("Erro ao criar um node!\n");
return NULL;
}
node->tuple = malloc(sizeof *node->tuple);
if (!node->tuple) {
printf("Erro ao criar o node->tuple\n");
free(node);
return NULL;
}
node->tuple->fields = malloc(slen * sizeof node->tuple->fields[0]);
if (!node->tuple->fields) {
printf("Erro ao criar o node->tuple->node_fields\n");
free(node->tuple);
free(node);
return NULL;
}
char arr[slen + 1];
strcpy(arr, s);
int i = split_str(arr, node->tuple->fields, " ");
node->tuple->n_fields = i;
node->tuple->timestamp = 0L;
node->next = NULL;
return node;
}
int split_str(char writablestring[], char **array, const char *sep)
{
char *token = strtok(writablestring, sep);
int i;
for (i = 0; token != NULL; i++) {
array[i] = malloc(strlen(token) + 1);
if (!array[i]) {
printf("Erro ao criar o array[i]\n");
break;
}
strcpy(array[i], token);
token = strtok(NULL, " ");
}
return i;
}
Try something like this instead:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct tuple_t
{
long timestamp; /* instante de criacao do tuplo*/
int n_fields; /* numero de campos deste tuplo */
char** fields; /* array com campos do tuplo */
};
struct node_t
{
struct tuple_t* tuple; //Entrada na lista
struct node_t* next; //o node seguinte da lista
};
char** split_str(const char *, const char *, int *);
void node_destroy(struct node_t*);
struct node_t* node_create(char* node_data)
{
struct node_t* node = (struct node_t *) malloc(sizeof(struct node_t));
if(!node)
{
printf("Erro ao criar um node!\n");
return NULL;
}
node->tuple = (struct tuple_t *) malloc(sizeof(struct tuple_t));
if(!node->tuple)
{
printf("Erro ao criar o node->tuple\n");
node_destroy(node);
return NULL;
}
node->tuple->timestamp = 0L;
node->tuple->fields = split_str(node_data, " ", &(node->tuple->n_fields));
if(!node->tuple->fields)
{
printf("Erro ao criar o node->tuple->node_fields\n");
node_destroy(node);
return NULL;
}
node->next = NULL;
return node;
}
void node_destroy(struct node_t* node)
{
if(node)
{
if(node->tuple)
{
if(node->tuple->fields)
{
for(int i = 0; i < node->tuple->n_fields; ++i)
free(node->tuple->fields[i]);
free(node->tuple->fields);
}
free(node->tuple);
}
free(node);
}
}
char** split_str(const char* str, const char* sep, int* found)
{
if (found) *found = 0;
int len = strlen(str);
char** array = (char**) malloc(len * sizeof(char*));
if(!array)
{
printf("Erro ao alocar memoria para o array em split\n");
return NULL;
}
++len;
char* writablestring = (char*) malloc(len);
if(!array)
{
printf("Erro ao alocar memoria para writeablestring em split\n");
free(array);
return -1;
}
strncpy(writablestring, str, len);
char* token = strtok(writablestring, sep);
int i = 0;
while(token)
{
len = strlen(token) + 1;
array[i] = (char*) malloc(len);
if(!array[i])
{
printf("Erro ao alocar memoria para o array item em split\n");
free(writeablestring);
for(int j = 0; j < i; ++j)
free(array[j]);
free(array);
return NULL;
}
strncpy(array[i], token, len);
++i;
token = strtok(NULL, sep);
}
free(writeablestring);
if(found) *found = i;
return array;
}
int main(int argc, char** argv)
{
char* n_data = "hello 123 ploc";
struct node_t* node = node_create(n_data);
if(node)
{
printf("node->tuple->n_fields=%d\n", node->tuple->n_fields);
for(int i = 0; i < node->tuple->n_fields; ++i)
printf("node->tuple->fields[%d]=%s\n", i, node->tuple->fields[i]);
node_destroy(node);
}
return 0;
}