Direttiva include e priorità

di zio_mangrovia il
9 risposte
Secondo voi è importante l'ordine in cui si descrivono le direttive di #include in testa ad un programma C++ ?

Mi è stato contestato durante un esame l'ordine che riceve impediva la compilazione corretta del programma ma la cosa non mi convince.

Nella fatti specie se inserisco:

#include "miofile.h"
#include <iostream>
#include <cstring>

è diverso da ?

#include "miofile.h"
#include <iostream>
#include <cstring>


Io pensavo che il compilatore avesse consapevolezza di quali sono le librerie senza preoccuparsi del loro ordine ma forse mi sbaglio?!

9 Risposte

  • L'ordine è importante ma tu hai mostrato la stessa sequenza
  • oregon ha scritto:


    L'ordine è importante ma tu hai mostrato la stessa sequenza
    Oops, correggo!

    #include <iostream>
    #include <cstring>
    #include "miofile.h"


    Avevo capito che con la direttiva include il compilatore incollasse semplicemene il file .h al .cpp.
    Credevo che fosse fondamentale che ogni funzione venisse dichiarata attraverso il suo prototipo ma non pensavo che fosse necessario rispettare un ordine.
    Mi chiedo invece perchè sia necessario.
  • Normalmente i file d'intestazione sono fatti per essere autosufficienti, per cui l'ordine non importa, ma se una interfaccia prevede delle dipendenze, allora l'ordine sarà quello necessario a soddisfare tali dipendenze. Te ne accorgi perché il compilatore ti avverte che mancano delle dichiarazioni.
  • Scusa ma tu cosa hai scritto in "miofile.h"?
  • Se hai queste due righe, ciascuna in un file h diverso:
    typedef int mioint;
    mioint a;
    l'ordine delle inclusioni é fondamentale.
  • candaluar ha scritto:


    Se hai queste due righe, ciascuna in un file h diverso:
    typedef int mioint;
    mioint a;
    l'ordine delle inclusioni é fondamentale.
    Esatto ... ed è solo uno dei casi ...

    Cosa c'è nel tuo include? E che errore hai?
  • Provo a spiegarmi.
    Questo il è file compito.h che avevo scritto:
    // compito.h
    #include <iostream>
    #include <cstring>
    using namespace std;
    
    class Display {
            int row;
            int col;
            int cur;
            char** dis;
    
    public:
            Display(int,int);
            Display(const Display&);
            friend ostream& operator<<(ostream& , const Display& ); 
    };
    
    
    // compito.cpp
    #include <iostream>
    #include <cstring>
    #include "compito.h"
    using namespace std;
    
    Display::Display(int L, int C)
    {
            if (L<1 || C<1) {
                    row=5;
                    col=8;
                    }
            else {
                    row=L;
                    col=C;
            }
            cur=0;
            int r,c;
            dis=new char*[row];
            for(r=0; r<row; r++)
                    dis[r]=new char[C+1];
            for(r=0; r<L; r++)
                    for(c=0; c<=C; c++)
                            dis[r][c]='\n';
    }
    
    ostream& operator<<(ostream& os, const Display& dd)
    {
            int r,c;
            for(r=0; r<(dd.row); r++) 
    //       {
    //               os << "["<< r;
    //                if (r==dd.cur && c==0)  
    //                        os << ">";
    //                os << dd.dis[r][c] << "]";
    //                for(c=0; c<dd.col; c++)         
    //                        if (dd.dis[r][c]!='') os << dd.dis[r];
    //                        os << endl;                             
    //      }
    
    return os;
    }
    Non è semplice ricostruire il percorso che ho fatto ma dovrebbe essere piuttosto attendibile quello che ho scritto.
    Avevo commentato tutte le righe della funzione operator per cercare di trovare l'errore, il compilatore diceva che l'attributo row era privato e non poteva essere acceduto( come se la funzione non fosse friend). Ho provato anche a spostare la funzione friend nella parte privata della classe ma il risultato era lo stesso.
    L'unico modo è stato invertire due direttive include, quella con compito.h era scritta per prima.
    Comunque ho riprodotto il problema anche a casa ma non ho avuto lo stesso comportamento, cioè il compilatore non dava errore sull'accesso all'attributo row. Rimane un enigma!

    A questo punto mi chiedo se nel main.cpp è corretto inserire soltanto :

    #include "compito.h"

    visto che le altre direttive sono già nel file .h, sbaglio?
  • Con quel codice non ho errori, dovresti essere molto più preciso e proporre esattamente il codice che ha dato il problema.
  • // compito.cpp
    #include "compito.h"
    #include <iostream>
    #include <cstring>
    using namespace std;
    In questo modo.
    L'unica differenza era questa, nel compito.cpp c'era gli header file invertiti.
    Anche a me sul mio calcolatore a casa non ha creato alcun errore il compilatore, eppure ti assicuro che non è stato fatto altro.

    Ma secondo voi, qual è l'approccio più corretto nella scrittura degli include sia nel .h che nel .cpp ?
    Cosa avreste scritto?
Devi accedere o registrarti per scrivere nel forum
9 risposte