Salve a tutti, riuscireste ad aiutarmi a capire che cosa va storto nell'esecuzione di questa libreria. In particolare ci sono dei problemi di esecuzione nella seconda funzione intersezione. Questo errore di segmentazione penso sia dovuto (anche se non ne sono sicuro ) ad un warning che il compilatore gcc di linux mi dà ossia: CONTROL REACHES END OF NON VOID FUNCTION nella riga 94 del file di definizione della libreria.
FILE DI TEST DELLA FUNZIONE:
#include<stdio.h>
#include<stdlib.h>
#include"ins.h"
void stampa_ins (insieme_t *);
int main (void)
{
insieme_t ins1, /*variabile per rappresentare il primo insieme */
ins2, /*variabile per rappresentare il secondo insieme */
*ret, /*variabile per l'insieme intersezione*/
*ins_diff, /*vafriabile per l'insieme differenza*/
*ins_diff_simm; /*variabile per l'insieme differenza simmetrica*/
int i, /*variabile per un ciclo for*/
ris, /*variabile per esito prima funzione*/
esito_lettura, /*variabile per la validazione stretta*/
j;
do /*validazione stertta e acquisizione del */
{ /*numero di elementi del primo insieme */
printf("Digitare il numero di elementi del primo insieme (>0) e premere invio:");
esito_lettura = scanf("%d",
&ins1. dim);
if ((ins1 . dim < 0) || (esito_lettura != 1))
{
printf("Input non accettabile!\n");
while(getchar() != '\n');
}
}
while ((ins1 . dim < 0) || (esito_lettura != 1));
ins1 . arr = (double *) calloc( ins1 . dim, sizeof(double)); /* allocazione di memoria in base al n° di elementi*/
for (ins1 . ind = 0; ( ins1 . ind) < (ins1 . dim); ins1 . ind ++) /* ciclo for per inserire gli elementi */
{ /* del primo insieme nell'array */
do
{
printf("Digitare l'elemento n°%d del primo insieme:",
ins1 . ind );
esito_lettura = scanf ("%lf",
&ins1 . arr[ins1 . ind]);
j = 0;
for( i = 0; i < ins1 . ind; i++)
{
if((ins1 . arr[ins1 . ind] == ins1 . arr[i]) || (esito_lettura != 1))
{
printf("Input non accettabile perche' uguale a un elemento già presente\n");
j = 1;
while(getchar() != '\n');
}
}
}
while((j == 1) || (esito_lettura != 1));
}
do /*validazione stertta e acquisizione del */
{ /*numero di elementi del secondo insieme */
printf("Digitare il numero di elementi del secondo insieme (>0) e premere invio:");
esito_lettura = scanf("%d",
&ins2 . dim);
if ((ins2 . dim < 0) || (esito_lettura != 1))
{
printf("Input non accettabile!\n");
while (getchar() != '\n');
}
}
while ((ins2 . dim < 0) || (esito_lettura != 1));
ins2 . arr = (double *) calloc( ins2 . dim, sizeof(double)); /* allocazione di memoria in base al n° di elementi*/
for (ins2 . ind = 0; ( ins2 . ind) < (ins2 . dim); ins2 . ind ++) /* ciclo for per inserire gli elementi */
{ /* del secondo insieme nell'array */
do
{
printf("Digitare l'elemento n°%d del secondo insieme:",
ins2 . ind );
esito_lettura = scanf ("%lf",
&ins2 . arr[ins2 . ind]);
j = 0;
for( i = 0; i < ins2 . ind; i++)
if((ins2 . arr[ins2 . ind] == ins2 . arr[i]) || (esito_lettura != 1))
{
printf("Input non accettabile perche' uguale a un elemento gia' presente\n");
j = 1;
while(getchar() != '\n');
}
}
while ( j == 1);
}
ins1 . ind = 0;
ris = confronto(ins1, ins2);
if(ris == 0)
printf("I due insiemi sono diversi.\n");
else
printf("I due insiemim sono uguali.");
ins1 . ind = 0;
ins2 . ind = 0;
/*ret = intersezione(ins1, ins2);
printf("\nFINE INTERSEZIONE\n");
if(ret == NULL)
printf("PORCODIO");
for(ret -> ind = 0; ret -> ind < ret -> dim; ret -> ind ++)
printf("\t%lf", ret -> arr[ret -> ind]);
if(ins_int1 == NULL)
printf("L'insieme intersezione non ha elementi");
else
{
printf("L'insieme intersezione ha %d elementi", ins_int1 -> dim);
stampa_ins(ins_int1);
}*/
ins1 .ind = 0;
ins2 . ind = 0;
ins_diff = differenza(ins1, ins2);
printf("L'insieme differenza ha i seguneti elementi:\n");
for (ins_diff -> ind = 0; ins_diff -> ind < ins_diff -> dim; ins_diff -> ind ++)
printf("%lf", ins_diff -> arr[ins_diff -> ind]);
/*stampa_ins(ins_diff);*/
ins1 . ind = 0;
ins2 . ind = 0;
ins_diff_simm = diff_simm(ins1, ins2);
printf("L'insieme differenza simmetrica ha i seguneti elementi:\n");
for (ins_diff_simm -> ind = 0; ins_diff_simm -> ind < ins_diff_simm -> dim; ins_diff_simm -> ind ++)
printf("%lf", ins_diff_simm -> arr[ins_diff_simm -> ind]);
/*stampa_ins(ins_diff_simm);*/
return(0);
}
void stampa_ins (insieme_t *ins)
{
for(ins -> ind = 0; ins -> ind < ins -> dim; ins -> ind ++)
{
printf("%lf \t", ins -> arr[ins -> ind]);
if(ins -> ind == ins -> dim --)
printf("\n");
}
ins -> ind = 0;
}
FILE DI INTESTAZIONE DELLA LIBRERIA:
typedef struct insieme
{
double *arr; /*array che andrà a contenere gli elementi dell'insieme*/
int dim; /*variabile per il numero di elementi dell'insieme*/
int ind; /*variabile indice per muoversi all'interno dell'array*/
} insieme_t;
extern int confronto ( insieme_t,
insieme_t);
extern insieme_t * intersezione ( insieme_t,
insieme_t);
extern insieme_t * differenza (insieme_t ins1,
insieme_t ins2);
extern insieme_t * diff_simm( insieme_t,
insieme_t);
FILE DI DEFINIZIONE DELLA LIBRERIA:
/*inclusione delle librerie*/
#include <stdio.h>
#include <stdlib.h>
/*definizionje del tipo di dato per rappresentare l'insieme*/
typedef struct insieme
{
double *arr; /*array che andrà a contenere gli elementi dell'insieme*/
int dim; /*variabile per il numero di elementi dell'insieme*/
int ind; /*variabile indice per muoversi all'interno dell'array*/
} insieme_t;
int confronto ( insieme_t, /*dichiarazione delle funzioni*/
insieme_t);
insieme_t * intersezione ( insieme_t,
insieme_t);
/*insieme_t * differenza ( insieme_t,
insieme_t);
insieme_t * diff_simm( insieme_t,
insieme_t);*/
/*definizione della funzione per confrontare due insiemi*/
int confronto ( insieme_t ins1, /*variabile per rappresentare il primo insieme*/
insieme_t ins2) /*variabile per rappresentare il secondo insieme*/
{
int risultato = 0; /*variabile per esportare nella main l'esito del confronto: 0 se diversi, 1 se uguali*/
if( (ins1 . dim) == (ins2 . dim) )
{
if( (ins1 . ind) < (ins1 . dim) )
{
for ( ins2 . ind = 0; (ins2 . ind) < (ins2 . dim); ins2 . ind ++)
if ( ins1 . arr[ ins1 . ind] == ins2 . arr[ins2 . ind] )
{
ins1 . ind ++;
risultato = confronto ( ins1, ins2);
}
}
else
risultato = 1;
}
else
risultato = 0;
return(risultato);
}
insieme_t * intersezione(insieme_t i1, insieme_t i2)
{
int k, j;
double temp;
static insieme_t * ret = NULL;
static unsigned int step = 0;
for(k = step; k < i1.dim; k++)
for(j = step; j < i2.dim; j++)
if(ret == NULL && i1.arr[k] == i2.arr[j])
{
temp = i1.arr[step];
i1.arr[step] = i1.arr[k];
i1.arr[k] = temp;
temp = i2.arr[step];
i2.arr[step] = i2.arr[j];
i2.arr[j] = temp;
step++;
intersezione(i1, i2);
}
if(ret == NULL)
{
ret = (insieme_t *)malloc(sizeof(insieme_t));
ret->dim = step;
if(step != 0){
ret->arr = (double *)malloc(step*sizeof(double));
while(step == 0)
{
ret->arr[step] = i1.arr[step];
step --;
}
}
else
ret->arr = NULL;
step = 0;
return ret;
}
}
/*definizione della funzione per il calcolo della differenza tra insiem*/
insieme_t * differenza(insieme_t i1, insieme_t i2)
{
int k, j;
double temp;
insieme_t * intersez = NULL;
static insieme_t * ret = NULL;
static int step = 0;
if(step < 0){
ret = NULL;
step = 0;
}
for(k = step; k < i1.dim; k++)
for(j = step; j < i2.dim; j++)
if(ret == NULL && i1.arr[k] == i2.arr[j]){
temp = i1.arr[step];
i1.arr[step] = i1.arr[k];
i1.arr[k] = temp;
temp = i2.arr[step];
i2.arr[step] = i2.arr[j];
i2.arr[j] = temp;
step++;
differenza(i1, i2);
}
if(ret == NULL){
intersez = (insieme_t *)malloc(sizeof(insieme_t));
if(intersez != NULL){
k = intersez->dim = step;
if(k > 0){
intersez->arr = (double *)malloc(k*sizeof(double));
if(intersez->arr != NULL){
while(k--)
intersez->arr[k] = i1.arr[k];
}
else
intersez = NULL;
}
}
if(intersez != NULL){
ret = (insieme_t *)malloc(sizeof(insieme_t));
if(ret != NULL){
k = ret->dim = i1.dim - intersez->dim;
if(k > 0){
ret->arr = (double *)malloc(k*sizeof(double));
if(ret->arr != NULL){
j = i1.dim
;
while(k--)
ret->arr[k] = i1.arr[--j];
}
else
ret = NULL;
}
}
}
}
step--;
return ret;
}
/*definizione della funzione per il calcolo della differenza simmetrica tra due insiemi*/
insieme_t * diff_simm(insieme_t ins1, /*variabile per rappresentare il primo insieme*/
insieme_t ins2) /*variabile per rappresentare il secondo insieme*/
{
insieme_t * ins_diff_simm = NULL, /*variabile per restituire alla main l'insieme differenza simmetrica*/
*insa,
*insb;
insa = differenza(ins1, ins2);
insb = differenza(ins2, ins1);
for(insa -> ind = 0; insa -> ind < insa -> dim; insa -> ind ++)
if(ins_diff_simm -> dim == 0)
{
ins_diff_simm -> dim = 1;
ins_diff_simm -> ind = 0;
ins_diff_simm -> arr= (double *) calloc( 1, sizeof(double));
ins_diff_simm -> arr[ins_diff_simm -> ind] = insa -> arr[insa -> ind];
}
else
{
ins_diff_simm -> dim ++;
ins_diff_simm -> ind ++;
ins_diff_simm -> arr = (double *) realloc(ins_diff_simm -> arr,ins_diff_simm -> dim * sizeof(double));
ins_diff_simm -> arr[ins_diff_simm -> ind] = insa -> arr[insa -> ind];
}
for(insb -> ind = 0; insb -> ind < insb -> dim; insb -> ind ++)
if(ins_diff_simm -> dim == 0)
{
ins_diff_simm -> dim = 1;
ins_diff_simm -> ind = 0;
ins_diff_simm -> arr= (double *) calloc( 1, sizeof(double));
ins_diff_simm -> arr[ins_diff_simm -> ind] = insb -> arr[insb -> ind];
}
else
{
ins_diff_simm -> dim ++;
ins_diff_simm -> ind ++;
ins_diff_simm -> arr = (double *) realloc(ins_diff_simm -> arr, ins_diff_simm -> dim * sizeof(double));
ins_diff_simm -> arr[ins_diff_simm -> ind] = insb -> arr[insb -> ind];
}
return(ins_diff_simm);
}
Grazie mille in anticipo.