Citation : Eusebus

Salut

Voici mon code, les explications suivent derrière :

main.c

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

#include "main.h"

int main(int argc, char **argv)
{
        matrice_t mat1, mat2, matc;

        srand(time(NULL));

        if(argc < 4)
        {       // L'utilisateur a lancé la console sans l'invite de commande ou a voulu faire le malin
                fprintf(stderr, "Usage : %s <nb_row> <nb_col1> <nb_col2>\n", argv[0]);
                exit(EXIT_FAILURE);
        }
// On récupère les arguments du main :
        mat1.nb_row = mat2.nb_row = atoi(argv[1]);
        mat1.nb_col = atoi(argv[2]);
        mat2.nb_col = atoi(argv[3]);


// On envoie mat1 et mat2 à init pour les remplir de valeurs pseudo-aléatoires :
        init(&mat1);
        init(&mat2);
// L'algorithme est appliqué :
        zaddition(&mat1, &mat2, &matc);
// On affiche le tout :
        printf("Matrice 1 :\n\n");
        affiche(&mat1);
        printf("\nMatrice 2 :\n\n");
        affiche(&mat2);
        printf("\nMatrice résultant de la concaténation :\n\n");
        affiche(&matc);

        liberer(&mat1);
        liberer(&mat2);
        liberer(&matc);

        return 0;
}

void init(matrice_t *mat)
{
        size_t i = 0, j = 0;

        mat->val = malloc(mat->nb_row * sizeof(int *)); Allocation pour les lignes

        for(i = 0; i < mat->nb_row; i++)
        {
                mat->val[i] = malloc(mat->nb_col * sizeof(int)); // Allocation pour les colonnes
                for(j = 0; j < mat->nb_col; j++)
                        mat->val[i][j] = rand() % 10; // nombre pseudo-aléatoire entre 0 et 10
        }
}

void affiche(matrice_t *mat)
{
        size_t i, j;

        for(i = 0; i < mat->nb_row; i++)
        {
                for(j = 0; j < mat->nb_col; j++)
                        printf("%d ", mat->val[i][j]);
                putchar('\n');
        }
}

void zaddition(matrice_t *mat1, matrice_t *mat2, matrice_t *mat)
{
        size_t i, j;

        mat->nb_row = mat1->nb_row;
        mat->nb_col = mat1->nb_col + mat2->nb_col;

        mat->val = malloc(mat->nb_row * sizeof(int *));

        for(i = 0; i < mat->nb_row; i++)
                mat->val[i] = malloc(mat->nb_col * sizeof(int));

        for(i = 0; i < mat->nb_row; i++)
                for(j = 0; j < mat->nb_col; j++)
                        if(j < mat1->nb_col)
                                mat->val[i][j] = mat1->val[i][j];
                        else
                                mat->val[i][j] = mat2->val[i][j - mat1->nb_col];
}

void liberer(matrice_t* mat)
{
    size_t i;
    for(i = 0; i < mat->nb_row; i++)
        free(mat->val[i]);
    free(mat->val);
}

main.h

#ifndef H_MAIN
#define H_MAIN

typedef struct
{
        int **val;
        size_t nb_row;
        size_t nb_col;
} matrice_t;

void init(matrice_t *mat);

void affiche(matrice_t *mat);

void zaddition(matrice_t *mat1, matrice_t *mat2, matrice_t *mat);

void liberer(matrice_t* mat);

#endif

Explications

En fait j'ai fait un peu plus que ce que l'exercice proposait, j'avais envie de m'amuser un peu. Je programme sous linux, ce qui explique que j'utilise assez souvent (et donc ici) les arguments du main.

Mon programme va générer des matrices (contenant des chiffres entre 0 et 9) de manière aléatoire, en fonction du nombre de lignes et de colonnes que l'on demande à l'appel du programme. Pour me simplifier la vie, j'ai défini une structure assez simple contenant le nombre de lignes, de colonnes et la matrice en elle-même. Cela me permet d'éviter d'avoir des fonctions avec un nombre trop important d'arguments.
Donc, trois fonctions, une pour initialiser les deux matrices à concaténer, une pour les afficher (le copier/coller de code, c'est moche => fonction), et la fonction zaddition à proprement parler.

L'utilisation de atoi ne fait pas planter le programme si l'utilisateur de fournit pas un nombre en argument au main, puisque dans ce cas atoi renvoie 0. J'ai décidé de ne pas me prendre la tête avec la gestion des erreurs (du style "l'argument rentré n'est pas correct", etc...), mais il faudrait le faire. Ah la flemme...

Sinon mon code compile sans warnings avec -W -Wall -ansi -pedantic et fonctionne parfaitement chez moi, j'ai testé avec différents arguments.

Un exemple :

eusebus@laptop:~/Progs/exos/zadd$ ./bla 5 6 8

Matrice 1 :

9 1 4 9 6 6
9 4 2 3 6 0
5 0 9 6 9 7
1 7 9 2 1 3
4 2 2 7 3 2

Matrice 2 :

3 5 3 9 4 1 6 5
8 0 8 4 0 5 7 1
2 6 0 5 6 9 7 7
4 4 1 7 1 6 1 6
1 4 6 7 8 4 2 6

Matrice résultant de la concaténation :

9 1 4 9 6 6 3 5 3 9 4 1 6 5
9 4 2 3 6 0 8 0 8 4 0 5 7 1
5 0 9 6 9 7 2 6 0 5 6 9 7 7
1 7 9 2 1 3 4 4 1 7 1 6 1 6
4 2 2 7 3 2 1 4 6 7 8 4 2 6

eusebus@laptop:~/Progs/exos/zadd$

Bonne fin de journée !

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

// declaration de mes fonctions
void affiche (int **tab,int ligne,int colonne);
void fonction (int **tab,int ligne,int colonne);
void concateneTab(int **tabA,int **tabB,int **tabResultat,int ligne,int colonneA,int colonneB);

//corps principal du programme
int main(int argc, char *argv[])
{
   int **tab1 = NULL;
   int **tab2 = NULL;
   int **tab3 = NULL;
   size_t i;

   int L =10;
   int C1 = 5;
   int C2 = 5;

    // allocation dynamique des tableaux
   tab1=malloc(L*sizeof(*tab1));
   tab2=malloc(L*sizeof(*tab2));
   tab3=malloc(L*sizeof(*tab3));
   for (i=0;i<L;i++)
   {
       tab1[i]=malloc(C1 * sizeof (**tab1));
       tab2[i]=malloc(C2 * sizeof (**tab2));
       tab3[i]=malloc((C1+C2) * sizeof (**tab3));
   }

   if ( (tab1 == NULL) || (tab2 == NULL) || (tab3 == NULL) )
   {
       printf("\n Erreur d'allocation de mémoire pour les tableaux \n");
       exit(0);
   }

   // on remplie les tableaux et on les affiche
   fonction(tab1,L,C1);
   affiche(tab1,L,C1);

   fonction(tab2,L,C2);
   affiche(tab2,L,C2);

   // on concatene les deux tableaux et on l'affiche
   concateneTab(tab1,tab2,tab3,L,C1,C2);
   affiche(tab3,L,C1+C2);





   // fin du programme on detruit les donnees en liberant la mémoire
   for (i=0;i<L;i++)
   {
    free(tab1[i]);
    free(tab2[i]);
    free(tab3[i]);
   }
   free(tab1);
   free(tab2);
   free(tab3);



    return 0;
}

// definition de mes fonctions
void affiche (int **tab,int ligne,int colonne)
{
    int i,j;
    for (i=0;i<ligne;i++)
    {
        for (j=0;j<colonne;j++)
        {
            printf("%3d",tab[i][j]);
        }
        printf("\n");
    }
    printf("\n\n");
}


void fonction (int **tab,int ligne,int colonne)
{
    int i,j,compteur;
    compteur = 0;
    for (i=0;i<ligne;i++)
    {
        for (j=0;j<colonne;j++)
        {
            tab[i][j]=compteur;
            compteur ++ ;
        }

    }
}

void concateneTab(int **tabA,int **tabB,int **tabResultat,int ligne,int colonneA,int colonneB)
{
    int i,j;

    for(i=0;i<ligne;i++)
    {
        for(j=0;j<colonneA;j++)
        {
            tabResultat[i][j]=tabA[i][j];
        }

        for(j=0;j<colonneB;j++)
        {
            tabResultat[i][j+colonneB]=tabB[i][j];
        }
    }
}

#include <stdio.h>
#include <stdlib.h> /* for atof() - in K&R, math.h is referenced - this is an anachronism */

#define MAXOP 100 /* max size of operand or operator */
#define NUMBER '0' /* signal that a number was found */

int getop(char []);
void push(double);
double pop(void);

/* reverse Polish calculator */

int main(void)
{
  int type;
  double op2;
  char s[MAXOP];

  while((type = getop(s)) != EOF)
  {
    switch(type)
    {
      case NUMBER:
        push(atof(s));
        break;
      case '+':
        push(pop() + pop());
        break;
      case '*':
        push(pop() * pop());
        break;
      case '-':
        op2 = pop();
        push(pop() - op2);
        break;
      case '/':
        op2 = pop();
        if(op2 != 0.0)
          push(pop() / op2);
        else
          printf("error: zero divisor\n");
        break;
      case '\n':
        printf("\t%.8g\n", pop());
        break;
      default:
        printf("error: unknown command %s\n", s);
        break;
    }
  }

  return 0;
}

#define MAXVAL  100 /* maximum depth of val stack */

int sp = 0; /* next free stack position */
double val[MAXVAL]; /* value stack */

/* push: push f onto value stack */
void push(double f)
{
  if(sp < MAXVAL)
    val[sp++] = f;
  else
    printf("error: stack full, can't push %g\n", f);
}

/* pop: pop and return top value from stack */
double pop(void)
{
  if(sp > 0)
    return val[--sp];
  else
  {
    printf("error: stack empty\n");
    return 0.0;
  }
}

#include <ctype.h>

int getch(void);
void ungetch(int);

/* getop: get next operator or numeric operand */
int getop(char s[])
{
  int i, c;

  while((s[0] = c = getch()) == ' ' || c == '\t')
    ;

  s[1] = '\0';
  if(!isdigit(c) && c != '.')
    return c; /* not a number */
  i = 0;
  if(isdigit(c)) /* collect integer part */
    while(isdigit(s[++i] = c = getch()))
      ;
  if(c == '.')
    while(isdigit(s[++i] = c = getch()))
      ;
  s[i] = '\0';
  if(c != EOF)
    ungetch(c);
  return NUMBER;
}

#define BUFSIZE 100

char buf[BUFSIZE]; /* buffer for ungetch */
int bufp = 0; /* next free position in buf */

int getch(void) /* get a (possibly pushed back) character */
{
  return (bufp > 0) ? buf[--bufp] : getchar();
}

void ungetch(int c) /* push character back on input */
{
  if(bufp >= BUFSIZE)
    printf("ungetch: too many characters\n");
  else
    buf[bufp++] = c;
}