Posizione librerie Visual C++

[lellus]

Si, so che un file .h è un header file, errori di giovinezza Avrei un'ultima domanda,diciamo un po' particolare. Mi trovo ad affrontare un lavoro in cui devo analizzare un programma scritto in C++ che è abbastanza complesso(si tratta di un simulatore che codifica e decodifica parole binarie usando un particolare algoritmo). Mi sto letteralmente perdendo ogni volta che provo a capirci qualcosa. Ho rinfrescato un po' di argomenti sul C++ e sulla programmazione ad oggetti ma comunque il codice è scritto in maniera troppo complessa per le mie capacità. Come mi consigliereste di procedere? Non posso studiarmi tutto sulla programmazione perché ho delle scadenze. Grazie a chi vorrà rispondere.

[fairyvilje]

Che costrutti vengono presentati che non ti sono chiari?
Il problema è nella sintassi del linguaggio o negli algoritmi implementati?

[lellus]

Il problema è che io ho una conoscenza di base della OOP e del C++ ma mi è stato posto davanti un lavoro che fa uso di aspetti avanzatissimi(almeno per me) della programmazione. Parlo di linguaggio C++ usato in maniera professionale. Molti costrutti li comprendo dato che mi sto documentando da tempo ma mi riesce comunque difficile comprendere a pieno come il programma fa determinate operazioni.

[lellus]

Inoltre visto che probabilmente nel futuro prossimo avrò a che fare con la programmazione avrei voglia di imparare e volevo qualche consiglio su come procedere. Sulla parte teorica c'è moltissimo su internet ma studiare la teoria è diverso rispetto al fare pratica. Ogni consiglio su come approcciare il problema è ben accetto.

[dimaios]

Il problema è che io ho una conoscenza di base della OOP e del C++ ma mi è stato posto davanti un lavoro che fa uso di aspetti avanzatissimi(almeno per me) della programmazione.

La prima cosa da vedere è se fa uso del C++ 11 o addirittura del 14.
Se invece si tratta di quello classico ( il C++98 per intenderci ) allora i consigli sono diversi.


1. Fai un esempio dei costrutti che ti mettono in difficoltà.
2. In che ambiente programmi ? Windows o Linux?

Sappi comunque che la programmazione ad oggetti è uno step mentale che richiede studio e molta pratica. Guardando gli esempi dei programmatori esperti si impara moltissimo ma per capire realmente si devono scrivere migliaia e migliaia di righe di codice.
Se il codice è già stato scritto da altri e funziona allora il problema si semplifica ammesso che lo abbiano scritto rispettando le best practices.

[lellus]

Programmo sotto windows con IDE visual studio express edition.Non sono tanto i costrutti o comunque non in particolare quelli quanto il fatto che essendo un programma abbastanza complicato è difficile seguirne lo sviluppo. E' un programma che codifica,modulazione,trasmissione,demodulazione e decodifica. Ecco una parte del main. Mi risulta difficile seguirne lo sviluppo.

Codice: Seleziona tutto

while(sim->get_FE()<sim->get_FEmax()) {
            /*
            |  Generazione
            */
            //source->fill_word(sim->Tx_infoword);
            /*
            |  Codifica
            */
            //encoder->encode_word(sim->Tx_infoword, sim->Tx_codeword);
            encoder->encode_word(NULL, sim->Tx_codeword);
            /*
            |  Modulazione
            */
            modulator->modulate_word(sim->Tx_codeword, sim->Tx_signalword);
            /*
            |  Trasmissione
            */
            channel->transmit_word(graph->actual_n / modulator->bits_per_signal(), sim->Tx_signalword, sim->Rx_signalword);
            /*
            |  Demodulazione
            */
            demodulator->demodulate_word(sim->Rx_signalword, sim->LLR);
            /*
            |  Punturazione
            */
            puncturer->PuncturateWord(sim->LLR);
            /*
            |  Decodifica
            */
            ParityCheck = decoder->decode_word(sim->LLR,
                                               sim->Estimate,
                                               sim->Rx_codeword,
                                               //sim->Rx_infoword,
                                               &IterationsNr);
            /*
            |  Verifica
            */
            sim->compare_words(ParityCheck/*, puncturer->PuncturedBits()*/);
         sim->increment_used_iterations(IterationsNr);

            /*
            |  Esegue azioni programmate
            */
            services->ScheduledActions();
        }
    }

[dimaios]

È un codice puramente procedurale per cui basta seguire il flusso delle istruzioni in modo sequenziale, non capisco dove ti incastri...... il C++ è ulilizzato solo per incapsulare i metodi ma di fatto vengono richiamate una serie di funzioni in successione.

[lellus]

Ad esempio non capisco la sintassi seguente:

Codice: Seleziona tutto

CINIFile *inifile;
    CLogger *logger;
    CPuncturer *puncturer;
    CGraph *graph;
    CGraph *compressedgraph;
    CSimulation *sim;
    CSource *source;
    CEncoder *encoder;
    CMQAMModulator *modulator;
    CMQAMDemodulator *demodulator;
    CAWGNChannel *channel;
    CDecoder *decoder;
    CServices *services;
    int IterationsNr;
    bool ParityCheck;

    /*
    |  Inizializzazione classi globali del sistema
    */
    services = new CServices(&inifile,
                             &logger,
                             &puncturer,
                             &graph,
                             &compressedgraph,
                             &sim,
                             &source,
                             &encoder,
                             &modulator,
                             &channel,
                             &demodulator,
                             &decoder);
    services->CreateGlobals();

Ho capito che dichiara vari puntatori alle classi e poi passa l'indirizzo dei puntatori al costruttore della classe CServices. Sbaglio?La cosa che non mi è chiara è il fatto che fa quel passaggio di parametri(che non so di che tipo è) senza aver inizializzato nulla. Ti e vi ringrazio per le risposte che mi state dando.

[fairyvilje]

(che non so di che tipo è)

Si tratta di puntatori a puntatori. È un modo per modificare dei puntatori noto il loro indirizzo nello scope esterno di una funzione per esempio, lasciandoli fruibili una volta terminata.
Si dichiarano con la sintassi:

Codice: Seleziona tutto

type** name;

Non serve inizializzare i puntatori iniziali perché probabilmente ci pensa la funzione chiamata a farlo :)

[dimaios]

Premetto che il codice che hai riportato nel "post" [18] contiene diversi errori che probabilmente non ne compromettono il funzionamento ma che sarebbero inaccettabili in un progetto industriale.
Siccome lo stile e le tecniche di programmazione non sono oggetto del thread procediamo con l'analisi funzionale del segmento di codice.

All'inizio vengono dichiarati dei puntatori alle varie classi.
Questi puntatori devono puntare a classi concrete e questo avviene attraverso la new.
Da un punto di vista stilistico è più corretto scrivere :

Codice: Seleziona tutto

CINIFile* inifile

che

Codice: Seleziona tutto

CINIFile *inifile

anche se il compilatore li interpreta nella stessa maniera.

La prima scrittura indica che inifile è un puntatore ad un oggetto di tipo CINIFile ovvero un "CINIFile puntatore".

Analogamente gli altri puntatori ai diversi oggetti.

Codice: Seleziona tutto

    CINIFile *inifile;
    CLogger *logger;
    CPuncturer *puncturer;
    CGraph *graph;
    CGraph *compressedgraph;
    CSimulation *sim;
    CSource *source;
    CEncoder *encoder;
    CMQAMModulator *modulator;
    CMQAMDemodulator *demodulator;
    CAWGNChannel *channel;
    CDecoder *decoder;
    CServices *services;
 

Di seguito viene richiamato il costruttore della classe CServices e come parametri vengono passati i vari puntatori che non puntano ancora al relativo oggetto poiché non è stata fatta una new.

services viene istanziato facendo la new di una classe CServices.
La new invoca il costruttore della classe CServices che evidentemente ha come parametri quelli che vedi nella lista.

Successivamente viene invocato il metodo pubblico CreateGlobals() dell'oggetto services appena creato che istanzierà i vari oggetti elencati nella lista dei parametri del costruttore ( inifile, logger, puncturer, graph ecc. )

Fondamentalmente si delega all'oggetto services la creazione di tutti gli altri oggetti.

Codice: Seleziona tutto

   
services = new CServices(&inifile,
                             &logger,
                             &puncturer,
                             &graph,
                             &compressedgraph,
                             &sim,
                             &source,
                             &encoder,
                             &modulator,
                             &channel,
                             &demodulator,
                             &decoder);

    services->CreateGlobals();


Ora l'ultimo punto è quello relativo al passaggio dei parametri.
Come mai viene utilizzato il simbolo &

Il simbolo & indica che i parametri devono essere passati per riferimento e non per valore.

Per capire la differenza puoi prendere un qualsiasi libro di C++ classico oppure leggi i seguenti articoli :
link 1
link 2

L'idea è comunque la seguente.
Prendiamo in esame la classe CINIFile.
Noi non vogliamo che l'oggetto inifile appartenga a services ma deve continuare ad appartenere al contesto dove viene dichiarato ( penso nel tuo caso sia nel main() del programma ).

Studia con attenzione il passaggio dei parametri per valore e per riferimento poi in caso ne riparliamo.