[WikiDyd] [TitleIndex] [WordIndex

Języki i metodyka programowania - kurs w sem. zimowym 2010/2011

Wykład X: 7 grudnia 2010

Dokończyliśmy program wystawiający oceny:

skala.h

   1 #ifndef _SKALA_H_
   2 #define _SKALA_H_
   3 
   4 int init( char * opis_skali );
   5 
   6 char * ocena( int liczba_punktow );
   7 
   8 #endif
   9 

skala.c

   1 #include "skala.h"
   2 #include <stdlib.h>
   3 #include <stdio.h>
   4 #include <string.h>
   5 
   6 typedef struct {
   7         int min_lp;
   8     char *oc;
   9 } step_t;
  10 
  11 int cm( const void *a, const void *b ) {
  12         step_t *sa= (step_t*) a;
  13         step_t *sb= (step_t*) b;
  14     return sa->min_lp - sb->min_lp;
  15 }
  16 
  17 static step_t domysl[] = { { 0, "2"},
  18                           { 51, "3.0" },
  19                           { 61, "3.5" },
  20                           { 71, "4.0" },
  21                           { 81, "4.5" },
  22                           { 91, "5.0" }
  23                                                 };
  24 
  25 static step_t *skala = domysl;
  26 static int wlk_skala = sizeof domysl / sizeof domysl[0];
  27 
  28 static char * out_of_nasza_skala_kochana = "?????????????";
  29 
  30 int init( char *opis ) { /* opis: np. "0:2;51:3;61:3.5;71:4;81:4.5;91:5" */
  31         step_t *nowa_skala= NULL;
  32     char *kawalek;
  33     int nowa_wlk= 0;
  34         int i;
  35     char *c;
  36         for( c= opis; *c != '\0'; c++ )
  37                 if( *c == ':' ) 
  38                         nowa_wlk++;
  39 
  40         if( (nowa_skala= malloc( nowa_wlk * sizeof *nowa_skala )) == NULL )
  41                 return -1;
  42 
  43     kawalek= opis;
  44     for( i= 0; i < nowa_wlk; i++ ) {
  45           char ocena[64]; /* ocena rzadko kiedy jest dłuższa niż 63 znaki */
  46       c= kawalek;
  47       while( *c != '\0' && *c != ';' )
  48                 c++;
  49       *c= '\0';
  50           if( sscanf( kawalek, "%d:%s",
  51            &nowa_skala[i].min_lp, ocena ) != 2 ) {
  52         int j;
  53         for( j= 0; j < i; j++ )
  54                         free( nowa_skala[j].oc );
  55                 free( nowa_skala );
  56         *c= ';';
  57                 return -10-i;
  58           } else {
  59                 nowa_skala[i].oc= malloc( strlen(ocena)+1 );
  60         strcpy( nowa_skala[i].oc, ocena );
  61       }
  62       *c= ';';
  63       kawalek = c+1;
  64     }
  65 
  66         skala= nowa_skala;
  67     wlk_skala= nowa_wlk;
  68     qsort( skala, wlk_skala, sizeof *skala, cm );
  69     return 0;
  70 }
  71 
  72 char *ocena( int lp ) {
  73         int i;
  74         for( i= wlk_skala - 1; i >= 0; i-- )
  75                 if( lp >= skala[i].min_lp )
  76                         return skala[i].oc;
  77         return out_of_nasza_skala_kochana;
  78 }

test_skali.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include "skala.h"
   4 
   5 int main( int argc, char **argv ) {
   6     int kb;
   7     if( kb= init( argv[1] ) ) {
   8         if( kb > -10 )
   9                         fprintf( stderr, "%s: brak pamięci na skalę\n", argv[0] );
  10         else
  11                     fprintf( stderr, "%s: nie podoba mi się \"%s\" (pozycja nr %d)\n", argv[0], argv[1], -(kb+10) );
  12         }
  13     argc--;
  14     argv++;
  15         while( --argc ) {
  16                 int lp = atoi( * ++argv );
  17         printf( "%d -> %s\n", lp, ocena( lp ) );
  18         }
  19         return 0;
  20 }

xocen.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include "stud.h"
   4 #include "lgrupa.h"
   5 #include "skala.h"
   6 
   7 #define MAX_LEN 256
   8 
   9 int
  10 main( int argc, char **argv ) {
  11 
  12         char imie[MAX_LEN];
  13         char nazwisko[MAX_LEN];
  14 
  15         lgrupa_t grupa;
  16 
  17     int i; /* zmienna robocza */
  18 
  19         FILE *in = argc > 1 ? fopen( argv[1], "r" ) : stdin;
  20     FILE *ou = argc > 2 ? fopen( argv[2], "w" ) : stdout;
  21 
  22         if( in == NULL || ou == NULL ) {
  23                 fprintf( stderr, "%s: niedobrze!\n", argv[0] );
  24                 return 1;
  25         }
  26 
  27         if( argc > 3 )
  28                 if( init( argv[3] ) )
  29           fprintf( stderr, "%s: skala \"%s\" jest zła, używam domyślnej skali.\n", argv[0], argv[3] );
  30 
  31     inicjuj_grupe( &grupa );
  32 
  33     while( fscanf( in, "%s %s %i", imie, nazwisko, &i ) == 3 )  {
  34                 if( dodaj_stud( &grupa, imie, nazwisko, i ) ) {
  35                         fprintf( stderr, "%s: brak pamieci!\n", argv[0] );
  36                         return 1;
  37                 }
  38         }
  39 
  40         sortuj_grupe( grupa, por_pkt );
  41 
  42         for( i= 0; i < wielkosc( grupa ); i++ ) {
  43                 stud_t *s= podaj_stud( grupa, i );
  44                 ocen( s, atof( ocena( ile_pkt( *s ) ) ) );
  45                 wypisz_stud( *s, ou );
  46         }
  47 
  48         return 0;
  49 }

Rozpoczęliśmy program rozwiązujący układ równań: matrix.h

   1 #ifndef _MATRIX_H_
   2 #define _MATRIX_H_
   3 
   4 #include <stdio.h>
   5 
   6 typedef struct {
   7         int rn;
   8     int cn;
   9     double *e;
  10 } matrix_t;
  11 
  12 matrix_t * make_matrix( int rn, int cn );
  13 
  14 matrix_t * read_matrix( FILE *in );
  15 
  16 void write_matrix( matrix_t *, FILE *out );
  17 
  18 #endif
  19 

matrix.c

   1 #include "matrix.h"
   2 
   3 matrix_t *make_matrix( int rn, int cn ) {
   4         matrix_t *new_mat= malloc( sizeof *new_mat );
   5     if( new_mat == NULL )
   6                 return NULL;
   7         if( (new_mat->e= malloc( rn*cn * sizeof * new_mat->e )) == NULL ) {
   8                 free( new_mat );
   9                 return NULL;
  10         }
  11     new_mat->rn= rn;
  12     new_mat->cn= cn;
  13         return new_mat;
  14 }
  15 
  16 matrix_t * read_matrix( FILE *in ) {
  17         int rn, cn;
  18     int i, j;
  19     matrix_t *new_mat;
  20         if( fscanf( in, "%d %d", &rn, &cn ) != 2 )
  21                 return NULL;
  22 
  23         new_mat= make_matrix( rn, cn );
  24         for( i= 0; i < rn; i++ )
  25                 for( j= 0; j < cn; j++ )
  26                         if( fscanf( in, "%lf", &new_mat->e[i*cn+j] ) != 1 ) {
  27                                 free_matrix( new_mat );
  28                                 return NULL;
  29                         }
  30 
  31         return new_mat;
  32 }

2015-09-23 06:44