Outils pour utilisateurs

Outils du site


fifo_objet

FIFOs et Programmation Orientée Objet

Programme à base de variables globales

main.cpp
#include <stdio.h>
 
#include <iostream>
using namespace std;
 
#include <QCoreApplication>
 
//initialisation faite directement
#define FIFO_SIZE 3
unsigned int fifo_size = FIFO_SIZE ;
unsigned int write_index = 0 ;
unsigned int read_index = 0 ;
unsigned int nb_available = 0 ;
char data[FIFO_SIZE] ;
 
//////////////////////////////////////////////////
////
/// \brief write_char_fifo
/// \param token : jeton a écrire dans la FIFO
/// \return 1 si valeur écrite dans la FIFO, 0 sinon
///
char write_char_fifo(const char token){
    if(nb_available >= fifo_size)
        return 0 ;  //FIFO PLEINE
    data[write_index] = token ;
    write_index++;
    if( write_index >= fifo_size)
        write_index = 0 ;
    nb_available++;
    return 1; //OK
}
//////////////////////////////////////////////////
///
/// \brief read_char_fifo
/// \param ptr_token : pointeur vers la zone mémoire dans laquelle ranger le jeton lu depuis la FIFO
/// \return  1 si valeur lue dans la FIFO, 0 sinon
///
char read_char_fifo( char * ptr_token){
    if( nb_available == 0)
        return 0; //FIFO VIDE
    *ptr_token=data[read_index];
    read_index ++;
    if( read_index >=  fifo_size)
        read_index = 0 ;
    nb_available--;
    return 1; //OK
}
//////////////////////////////////////////////////
int main(int argc, char *argv[])
{
 
    printf("salut les APP\r\n");
 
    cout << "Hello World!" << endl;
    /*write_char_fifo(5);
    write_char_fifo(1);
    write_char_fifo(7);*/
    for (int i=0;i<10;i++)
        if (write_char_fifo(i)==0)
           cout << "fifo pleine "<< endl;
 
    for (int i=0;i<10;i++){
        //rien n'empêche un utilisateur d'écrire
        //nb_available=5; //grosse bétise!
 
        char c;
        if (read_char_fifo(&c)!=0)
            cout << "donnée lue dans la fifo: " << +c << endl;
        else
            cout << "fifo vide "<< endl;
    }
    printf("fin\r\n");
}

Programme à base de structures

main2.cpp
#include <stdio.h>
 
#include <iostream>
using namespace std;
 
#include <QCoreApplication>
 
//initialisation faite directement
 
 
struct charFifo{
  char * data ;
  unsigned int fifo_size ;
  unsigned int write_index ;
  unsigned int read_index ;
  unsigned int nb_available ;
};
 
#define FIFO_SIZE1 3
char FifoBuffer[FIFO_SIZE1];
struct charFifo myFifo;    // la variable FIFO à utiliser
 
#define FIFO_SIZE2 4
char FifoBuffer2[FIFO_SIZE2];
struct charFifo myFifo2;
////////////////////////////////////////
////
/// \brief init_char_fifo
/// \param pf
/// \param buf
/// \param f_size
///
void init_char_fifo(struct charFifo * ptr_fif, char * buf, unsigned int f_size){
//(*ptr_fif).fifo_size=f_size;
ptr_fif->fifo_size=f_size;
ptr_fif->nb_available=0;
ptr_fif->write_index=0;
ptr_fif->read_index=0;
ptr_fif->data=buf;
 
}
 
//////////////////////////////////////////////////
////
/// \brief write_char_fifo
/// \ptr_fif : pointeur vers la fifo dans laquelle écrire
/// \param token : jeton a écrire dans la FIFO
/// \return 1 si valeur écrite dans la FIFO, 0 sinon
///
char write_char_fifo(struct charFifo * ptr_fif, const char token){
    if(ptr_fif->nb_available >= ptr_fif->fifo_size)
        return 0 ;  //FIFO PLEINE
    ptr_fif->data[ptr_fif->write_index] = token ;
    (ptr_fif->write_index)++;
    if( ptr_fif->write_index >= ptr_fif->fifo_size)
        ptr_fif->write_index = 0 ;
    ptr_fif->nb_available++;
    return 1; //OK
}
 
//////////////////////////////////////////////////
///
/// \brief read_char_fifo
/// \ptr_fif : pointeur vers la fifo dans laquelle écrire
/// \param ptr_token : pointeur vers la zone mémoire dans laquelle ranger le jeton lu depuis la FIFO
/// \return  1 si valeur lue dans la FIFO, 0 sinon
///
char read_char_fifo(struct charFifo * ptr_fif, char * ptr_token){
    if( ptr_fif->nb_available == 0)
        return 0; //FIFO VIDE
    *ptr_token=ptr_fif->data[ptr_fif->read_index];
    (ptr_fif->read_index )++;
    if( ptr_fif->read_index >=  ptr_fif->fifo_size)
        ptr_fif->read_index = 0 ;
    ptr_fif->nb_available--;
    return 1; //OK
}
//////////////////////////////////////////////////
int main(int argc, char *argv[])
{
 
    printf("salut les APP\r\n");
 
    char lu;
    init_char_fifo(&myFifo, FifoBuffer,  FIFO_SIZE1);
    read_char_fifo(&myFifo, &lu) ;
    write_char_fifo(&myFifo, 5) ;
    write_char_fifo(&myFifo, 8) ;
    read_char_fifo(&myFifo, &lu) ;
    write_char_fifo(&myFifo, 12) ;
    write_char_fifo(&myFifo, 1) ;
    write_char_fifo(&myFifo, 7) ;
    read_char_fifo(&myFifo, &lu) ;
    read_char_fifo(&myFifo, &lu) ;
    read_char_fifo(&myFifo, &lu) ;
    read_char_fifo(&myFifo, &lu) ;
 
}

Solution Question 2.5 du TD:

Programme avec approche objet

testapp.pro
QT += core
QT -= gui
 
TARGET = testapp
CONFIG += console
CONFIG -= app_bundle
 
TEMPLATE = app
 
SOURCES += main.cpp
SOURCES += fifo.cpp
SOURCES += fifoavecreinit.cpp
 
HEADERS+= fifo.h
HEADERS+= fifoavecreinit.h
fifo.h
#ifndef FIFO_H
#define FIFO_H
#include <iostream>
class Fifo
{
public:
    Fifo(unsigned int f_size=15); //paramètre par défaut
    ~Fifo();
    char write_char(const char token);
    char read_char(char * token);
    int get_nb_available();
    //les méthodes templates sont inlinées, on met le code dans le .h
    friend std::ostream &operator<<( std::ostream &output,Fifo &F )
    { char car;
        if (F.read_char(&car)==1)
            output <<  car ;
        else
            output <<  "FIFO VIDE" ;
        return output;
    }
    friend std::istream &operator>>( std::istream  &input, Fifo &F )
    {
        char car;
        input >> car;
        F.write_char(car); //pas de vérification de place disponible dans la fifo, hic
        return input;
    }
    //ces attributs sont rendus privés pour éviter qu'un utilisateur de la classe puisse les modifier
private:
    char * data ;
    unsigned int fifo_size ;
    //les attributs suivants seront modifiables par les classes filles
protected:
    unsigned int write_index ;
    unsigned int read_index ;
    unsigned int nb_available ;
 
};
#endif // FIFO_H
fifo.cpp
#include "fifo.h"
 
using namespace std;
 
//#define DEBUGFIFO
 
////////////////////////////////////////////
Fifo::Fifo(unsigned int f_size)
{
    cout << "construction d'une fifo" << endl;
    this->data=new char(f_size);    //allocation de data
    this->fifo_size = f_size ;
    this->write_index = 0 ;
    this->read_index = 0 ;
    this->nb_available = 0 ;
}
////////////////////////////////////////////
Fifo::~Fifo()
{
    delete(this->data);    //libération de data
}
////////////////////////////////////////////
char Fifo::write_char(const char token){
    if(this->nb_available >= this->fifo_size) return 0 ;
    this->data[this->write_index] = token ;
    this->write_index = this->write_index + 1;
    if(this->write_index >= this->fifo_size) this->write_index = 0 ;
    this->nb_available = this->nb_available + 1 ;
    return 1 ;
}
////////////////////////////////////////////
char Fifo::read_char(char * token){
    if(this->nb_available == 0) return 0;
    *token = this->data[this->read_index]  ;
    this->read_index = this->read_index + 1;
    if(this->read_index >= this->fifo_size) this->read_index = 0 ;
    this->nb_available = this->nb_available -1 ;
    return 1 ;
}
////////////////////////////////////////////
int Fifo::get_nb_available() {
#ifdef DEBUGFIFO
    cout <<" get_nb_available() a été invoquée"<<endl;
#endif
    return  this->nb_available;
}
fifoavecreinit.h
#ifndef FIFOAVECREINIT_H
#define FIFOAVECREINIT_H
#include "fifo.h"
class FifoAvecReinit : public Fifo
{
public:
    FifoAvecReinit();
    void reinit();
};
 
#endif // FIFOAVECREINIT_H
fifoavecreinit.cpp
#include "fifoavecreinit.h"
#include <iostream>
using namespace std;
////////////////////////////////////////////
FifoAvecReinit::FifoAvecReinit()
{
    cout << "construction d'une fifoAvecReinit" << endl;
}
////////////////////////////////////////////
void FifoAvecReinit::reinit()
{
    this->nb_available=0;
    this->read_index=0;
    this->write_index=0;
}
main.cpp
#include <stdio.h>
 
#include <iostream>
using namespace std;
 
#include "fifo.h"
 
#include "fifoavecreinit.h"
 
Fifo fifo1(3); //initialisation de la FIFO
// init_char_fifo(&myFifo, FifoBuffer,  FIFO_SIZE1);
 
 
//////////////////////////////////////////////////
int main(int argc, char *argv[])
{
 
    printf("salut les APP\r\n");
    cout << "Hello World!" << endl;
 
 
    Fifo * ptr_fifo5;
 
    ptr_fifo5=new Fifo(100000000);
    ptr_fifo5->write_char(1);
    ptr_fifo5->write_char(2);
    ptr_fifo5->write_char(3);
    delete(ptr_fifo5);
 
 
 
    Fifo * tab_ptr_fifo[100];
    for (int i=0;i<100;i++)
        tab_ptr_fifo[i]=new Fifo(1000);
 
    tab_ptr_fifo[12]->write_char(6);
 
 
    //init_char_fifo(&myFifo, (char*)4,3);
 
    char lu;
 
    //fifo1.nb_available=8; //interdit grace à l'encapsulation
    fifo1.read_char(&lu);
    fifo1.write_char(5);
    fifo1.write_char(8);
    fifo1.read_char(&lu);
    fifo1.write_char(12);
    fifo1.write_char(1);
 
    cout << "données disponibles dans la fifo: " << +fifo1.get_nb_available() << endl;
 
 
    fifo1.write_char(7);
    fifo1.read_char(&lu);
    fifo1.read_char(&lu);
    fifo1.read_char(&lu);
    fifo1.read_char(&lu);
 
/*
    Fifo fifo2(20); //une autre FIFO, de taille 20, qui n'est pas la taille par défaut
    fifo2.write_char('3');
    cout << "Il y a " <<  fifo2.get_nb_available()  <<" données dans la fifo 3" << endl;
    cout << "entrer 3 valeurs à ranger dans la fifo" <<endl;
    cin >> fifo2;
    cin >> fifo2;
    cin >> fifo2;
 
    cout << "Il y a " <<  fifo2.get_nb_available()  <<" données dans la fifo 3" << endl;
    cout << fifo2 << " " << fifo2 <<  " " << fifo2 << " " << fifo2 << " " << fifo2 <<   endl;
*/
 
 
    FifoAvecReinit fifo3;
    fifo3.write_char(1);
    fifo3.write_char(2);
    fifo3.write_char(3);
    fifo3.write_char(4);
    fifo3.read_char(&lu);
    fifo3.reinit();
    fifo3.read_char(&lu);
 
 
 
 
 
    /*write_char_fifo(5);
    write_char_fifo(1);
    write_char_fifo(7);*/
  /*  for (int i=0;i<10;i++)
        if (write_char_fifo(i)==0)
           cout << "fifo pleine "<< endl;
 
    for (int i=0;i<10;i++){
        //rien n'empêche un utilisateur d'écrire
        //nb_available=5; //grosse bétise!
 
        char c;
        if (read_char_fifo(&c)!=0)
            cout << "donnée lue dans la fifo: " << +c << endl;
        else
            cout << "fifo vide "<< endl;
    }
 
 
    data[2]=5 ;
 
    *(data+2)=6;
*/
    printf("fin\r\n");
}

Procédure d'installation de QTcreator 5

Wireshark pour Windows 10

Récupération des sources pour compiler les applications de démo

fifo_objet.txt · Dernière modification: 2020/03/27 16:06 par bvandepo