[C] Librairie gestion de tableaux

12 mars 2006 à 18:06:26

Bonjour

Je crois qu'il n'y a pas de librairie standard qui manipule les tableaux donc j'ai crée une petite librairie pour la gestion de tableaux, elle contient les exercices sur les tableaux du cours, et d'autres donc je cherche à l'améliorer en faisant d'autres fonctions mais malheureusement je n'ai plus d'idées.

Vous pouvez bien entendu apporter des modifications pour vos programmes (si ça vous sert

).

tables.c :

/*
* tables.c (created by kr00ps)
*
* Date : 12/03/2006
*
* This file is in the Public Domain and is not copyrighted.
*
*/

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

int main(void)
{
return 0;
}

void tblgenerationvalues(int table[]‚ int size‚ int min‚ int max)
{
int element_to_inserer‚ j;

srand(time(NULL));

for (j = 0; j < size; j++)
{
element_to_inserer = (rand() % (max – min + 1)) + min;
table[j] = element_to_inserer;
}
}

void tblcopy(const int table1[]‚ int table2[]‚ int size)
{
int j;

for(j = 0; j < size; j++)
{
table2[j] = table1[j];
}
}

void tblprint(int table[]‚ int size)
{
int j;

for(j = 0; j < size; j++)
{
printf("%d "‚ table[j]);
}
}

void tblorder(int table[]‚ int size)
{
int j‚ temp‚ element_to_inserer‚ current_element‚ k;

for (j = 0; j < size; j++)
{
element_to_inserer = table[j];

for(k = 0; k < j; ++k)
{
current_element = table[k];

if (element_to_inserer < current_element)
{
table[k] = element_to_inserer;
element_to_inserer = current_element;
}
}

table[j] = element_to_inserer;
}
}

int tblsum(int table[]‚ int size)
{
int j‚ sum = 0;

for(j = 0; j < size; j++)
{
sum += table[j];
}

return sum;
}

double tblaverage(int table[]‚ int size)
{
int j‚ sum = 0;

for(j = 0; j < size; j++)
{
sum += table[j];
}

return sum / size;
}

void tblmaximum(int table[]‚ int size‚ int maximum)
{
int j;

for(j = 0; j < size; j++)
{
if (table[j] > maximum)
{
table[j] = 0;
}
}
}

tables.h :

/*
/*
* tables.h (created by kr00ps)
*
* Date : 12/03/2006
*
* This file is in the Public Domain and is not copyrighted.
*
*/

#ifndef HEADER_TABLES
#define HEADER_TABLES

void tblgenerationvalues(int table[]‚ int size‚ int min‚ int max);

void tblcopy(const int table1[]‚ int table2[]‚ int size);

void tblprint(int table[]‚ int size);

void tblorder(int table[]‚ int size);

int tblsum(int table[]‚ int size);

double tblaverage(int table[]‚ int size);

void tblmaximum(int table[]‚ int size‚ int maximum);

#endif

J'attends vos suggestions et critiques.

Kr00pS

-ed-

12 mars 2006 à 18:12:16

Citation : Kr00pS

Je crois qu'il n'y a pas de librairie standard qui manipule les tableaux donc j'ai crée une petite librairie pour la gestion de tableaux, elle contient les exercices sur les tableaux du cours, et d'autres donc je cherche à l'améliorer en faisant d'autres fonctions mais malheureusement je n'ai plus d'idées.

Je n'ai pas regardé en détail mais l'idée est bonne. Le problème est qu'elle dépend du type. En C++, le problème est résolu par les templates, mais il n'y a rien de tel en C.

Par contre, il existe des techniques un peu 'avancées' qui permettent d'écrire du code 'générique', c'est à dire indépendant du type dont on ne garde qu'une caractéristique : sa taille en bytes. Pour ça, on manipule un objet tableau qui contient :

Taille de l'élément
Nombre d'elements
Adresse d'origine

Music only !

Kr00pS

12 mars 2006 à 18:18:31

Citation : -ed-

Citation : Kr00pS

Je crois qu'il n'y a pas de librairie standard qui manipule les tableaux donc j'ai crée une petite librairie pour la gestion de tableaux, elle contient les exercices sur les tableaux du cours, et d'autres donc je cherche à l'améliorer en faisant d'autres fonctions mais malheureusement je n'ai plus d'idées.

Je n'ai pas regardé en détail mais l'idée est bonne. Le problème est qu'elle dépend du type. En C++, le problème est résolu par les templates, mais il n'y a rien de tel en C.

Par contre, il existe des techniques un peu 'avancées' qui permettent d'écrire du code 'générique', c'est à dire indépendant du type dont on ne garde qu'une caractéristique : sa taille en bytes. Pour ça, on manipule un objet tableau qui contient :

Taille de l'élément

Nombre d'elements

Adresse d'origine

Oui, je n'ai pas trouvé de moyen de rendre ça "universel".

Merci pour la solution, je vais essayer de resoudre ça.

Avec une structure ?

typedef struct Template Template;
struct Template
{
int size_of_elements;
int number_of_elements;
int *pointer_toward_type;
};

asmanur

12 mars 2006 à 19:49:22

-ed-, si tu prends des pointeurs génériques, des tailles en byte et tout le tralalala tu as la lib string.h (memset,memchr,memcpy and co), qui est parfaitement standard

bluestorm

12 mars 2006 à 19:56:04

Hum, je dirais que déja les noms des fonctions sont pas terribles :
"generation_values_table" : ecrit soit en francais, soit en anglais, mais par pitié évite de mélanger les deux dans un seul nom...

copy_table1_in_table2 > tblcpy serait plus 'C-like' (à la strcpy).

element_to_be_inserer >

I have got l'impression que tu shuffle un peu les tongues dans tes names de variables.

Kr00pS

12 mars 2006 à 20:01:58

Je sais je ne suis pas très bon en Anglais

Désolé, je vais essayer de corriger ça.

EDIT : Voila j'ai essayé de corriger.

-ed-

12 mars 2006 à 20:45:02

Citation : asmanur

-ed-, si tu prends des pointeurs génériques, des tailles en byte et tout le tralalala tu as la lib string.h (memset,memchr,memcpy and co), qui est parfaitement standard

Oui, pour implémenter, je suis d'accord. Mais c'est gore et ce genre de détails, je préfère les mettre une fois dans des fonctions qui font le travail.
Secret (cliquez pour afficher)

<lien url="http://mapage.noos.fr/emdel/clib.htm">http://mapage.noos.fr/emdel/clib.htm</lien>
Module FARR (Flexible Array)

Music only !

Kr00pS

12 mars 2006 à 20:55:40

Si vous pourriez me donner un exemple d'utilisation ça serait beaucoup mieux pour moi car dans la bibliothèque CLIB je ne comprends rien

-ed-

12 mars 2006 à 21:14:34

Citation : Kr00pS

Si vous pourriez me donner un exemple d'utilisation ça serait beaucoup mieux pour moi car dans la bibliothèque CLIB je ne comprends rien

Cette information (CLIB) ne t'était pas destinée...

Sinon, à partir de la structure de tableau générique à une dimension,

typedef struct
{
size_t size_of_elements;
size_t number_of_elements;
void *pointer_toward_type;
}
Template;

on peut faire ceci :

#include "template.h"

int main (void)
{
Template a_int;

/* creation d'un tableau de 12 int */
int err = Template_init(&a_int‚ sizeof (int)‚ 12);
if (!err)
{
/* remplissage */
Template_fill(&a_int);

/* mettre une donnee dans un element */
{
int data = 123;
Template_write(&a_int‚ &data‚ 8);
}

/* recuperer une donnee d'un element */
{
int data; /* EDIT (erreur de frappe) */
Template_read(&a_int‚ &data‚ 8);

printf ("data = %d\n"‚ data);
}

/* destruction */
Template_end(&a_int);
}

return 0;
}

Reste plus qu'à écrire le code... dans un fichier "template.c", et à refaire un test avec un tableau de 5 chaines de 8 char, par exemple...

Le fichier "template.h" contien la défintions de la structure, les prototypes, et les includes nécessaire aux définitions

size_t est defini dans <stddef.h>

Music only !

asmanur

13 mars 2006 à 7:06:40

Citation : -ed-

int &data;

omg

Le truc qui n'estpas pratique hélas, c'est qu'il faut passer par une variable temporaire

-ed-

13 mars 2006 à 8:30:35

Citation : asmanur

Citation : -ed-

int &data;

Le truc qui n'estpas pratique hélas, c'est qu'il faut passer par une variable temporaire

C'est le cas dans la plupart des cas réels. Il est extrêmement rare que l'on manipule des expressions constantes dans le cas de véritables applications. En fait, dans la plupart des cas, ce sont des structures ou des pointeurs sur des structures, parfois des pointeurs sur des chaines de caractères ou des tableaux...

Au fait, le & était en trop, je pensais déjà à la suite...
Corrigé.

int data;

Music only !

bluestorm

13 mars 2006 à 9:07:57

Accessoirement, on peut aussi utiliser un typedef pour masquer le type manipulé par la lib, et si on veut changer de type, on change juste le typedef.
Ca permet pas un réel polymorphisme, mais pour un débutant c'est pas mal plus simple quand même.

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

/* type et fonctions dépendantes */
typedef int elem;

elem max(elem a‚ elem b)
{
return ((a > b) ? a : b);
}

void read(elem *a)
{
printf("Entrez un element :\t");
scanf("%d"‚ a);
}

/* fonctions indépendantes du type */
elem * table_create(int length)
{
elem *tab;

assert(length > 0);

tab = malloc(length * sizeof(elem));

return tab;
}

elem table_fold(elem start‚ elem fun(elem‚ elem)‚ elem tab[]‚ int length)
{
int i;
elem result = start;

for (i = 0; i < length; ++i)
result = fun(result‚ tab[i]);
return result;
}

void table_iter(void fun(elem *)‚ elem tab[]‚ int length)
{
int i;
printf("taille : %d\n"‚ length);
for (i = 0; i < length; ++i)
fun(tab + i);
}

int main(void)
{
int taille;
elem *tab;

printf("quelle taille ?\t");
scanf("%d"‚ &taille);

tab = table_create(taille);
table_iter(read‚ tab‚ taille);

printf("Le maximum est %d\n"‚ table_fold(0‚ max‚ tab‚ taille));

free(tab);
return 0;
}

Il suffit qu'on change le 'int' du typedef en 'float', et en modifiant la fonction read (mettre %f) et le printf du main (mettre %f) on a exactement la même chose. On pourrait aussi l'étendre à des struct, des couples de nombres...