Wie auto-zählen alle Header im Verzeichnis

Werde ich durch übungen ein C++ Buch. Für jede übung, die ich will, zu minimieren, die boilerplate-code, den ich zu schreiben habe. Ich habe mein Projekt auf eine bestimmte Weise, aber es scheint nicht richtig, und erfordert zu viele änderungen.

Momentan habe ich ein Einzelzimmer main.cpp - Datei mit dem folgenden:

#include "e0614.h"
int main()
{
    E0614 ex;
    ex.solve();
}

Jedes mal, wenn ich eine neue Klasse erstellen, die von einer übung, die ich habe, zu kommen und ändern Sie diese Datei ändern Sie den Namen der eingebundenen header-als auch die Klasse ich bin instanziieren.

Also meine Fragen sind:

Kann ich alle Header in das Verzeichnis, also zumindest ich nicht haben, ändern Sie die #include Linie?
Noch besser, kann ich umschreiben, meine Lösung, so dass ich mich gar nicht zu berühren main.cpp ohne dass eine Datei mit allen code für jede übung?

Update:

Landete ich folgende Poita_ Beratung generieren main.cpp über ein script.

Da bin ich mit einer IDE (Visual Studio), wollte ich diese mit integriert, also habe ein wenig Forschung auf, wie. Für diejenigen, die interessiert, wie, Lesen Sie auf (es war ziemlich, aber nicht ganz einfach).

Visual Studio können Sie ein externes tool über das Tools -> External Tools Menü, und enthält eine Reihe von vordefinierten Variablen, wie $(ItemFileName), die weitergegeben werden können, um das Werkzeug. Also in diesem Beispiel habe ich eine einfache batch-Datei, und es wird übergeben Sie den Namen der aktuell ausgewählten Datei in Visual Studio.

Hinzufügen, dass tool auf der Symbolleiste mit der rechten Maustaste auf die Symbolleiste, wählen Sie Anpassen -> Befehle -> Extras, und wählen Sie die "External-Command-X" und ziehen Sie es auf die Symbolleiste. Ersetzen Sie X durch die entsprechende Nummer für das Werkzeug, das Sie erstellt haben. Meine installation enthalten sind 5 Standard-pre-bestehenden aufgelisteten tools im Tools -> External Tools, also der, den ich schuf, war Werkzeug Nummer 6. Sie haben, um herauszufinden, diese Nummer, wie es ist, nicht angezeigt. Sie können dann ordnen Sie ein Symbol, um die Verknüpfung (es ist die BuildMain Befehl siehe unten):

alt-text http://img691.imageshack.us/img691/4853/capturerg.png

Sorry, aber es gibt kaum einen vorformulierten hier. - Was Sie fordern - auch auf alle möglichen Header - spart man vielleicht 2 Sekunden von der Eingabe (einmalige Kosten) und mit etwas Glück können einfache code-Kompilierung für zehn Minuten (jedes mal, wenn Sie neu kompilieren).
das Hauptziel ist nicht wirklich alle Header, aber zu vermeiden, ändern main.cpp. Ich entschied, dass, wie der Frage-Titel es einfach zu machen, und ich dachte, es könnte möglich sein, haben einige #ifdef Wachen auf dem Weg.

InformationsquelleAutor JRL | 2010-03-12

c++include

14
1. Nicht. Sie haben, um Sie alle, wenn das, was Sie tun möchten.
2. Nicht. Zumindest nicht in einer Weise, die tatsächlich zum speichern der Eingabe.
Natürlich, könnten Sie ein Skript schreiben zu erstellen main.cpp für Sie...

+1 für den Vorschlag eines Skript

InformationsquelleAutor Peter Alexander
9

Wenn Ihr euren code mit make Sie sollten in der Lage sein, dies zu tun.

Kann ich alle Header in das Verzeichnis, also zumindest ich nicht haben, ändern Sie die #include-Zeile?

Ändern Sie Ihre include-Zeile etwas wie #include <all_headers.h>. Nun, Sie können lassen Sie Ihr Makefile automatisch generieren all_headers.h mit einem Ziel wie:
```
all_headers.h:
    for i in `ls *.h`; do echo "#include <$i>" >>all_headers.h; done
```
Stellen Sie sicher, dass all_headers.h wird immer gelöscht, wenn man 'make clean'.

Besser noch, kann ich umschreiben, meine Lösung, so dass ich mich gar nicht zu berühren main.cpp,
ohne eine Datei mit allen code für jede übung?

Können Sie dies tun, wenn Sie abstrahieren Ihre Klasse mit einem typedef. In deinem Beispiel, ändern Sie Ihre Klasse Namen von E0614 zu myClass (oder so). Nun, fügen Sie eine Zeile zu Ihrem Makefile unter der for Schleife oben, sagt echo "typedef "$MY_TYPE" myClass;" >>all_headers.h. Wenn Sie bauen Ihr Programm, aufrufen von 'make' mit so etwas wie make MY_TYPE=E0614 und Ihre typedef wird automatisch gefüllt mit der Klasse, die Sie wollen, um zu testen.

Es gibt ein problem mit den build-Regel: es wird nicht abholen neue Header, es sei denn, Sie manuell make clean oder trash all_headers.h. Bedenkt, dass er die schrittweise Vollendung übungen aus einem Buch, ist dies ein wesentliches Hemmnis.
Ich würde nicht nennen es eine "erhebliche" Behinderung. Wenn er das hinzufügen neuer Quelldateien, die er wahrscheinlich tun eine make rebuild jedes mal, wenn eh (über ein Ziel wie rebuild: clean build).

InformationsquelleAutor bta
3

Wenn Sie auf Unix system haben, können Sie ein Link verweist auf die aktuelle übung.

ln -s e0615.h die Letzte.h

Namen und deine Klasse E statt E0614, natürlich

P. S. Nach meinem besten wissen, können Sie nicht tun #include xxx*

InformationsquelleAutor DVK
1

Keine main.cpp was Sie ändern für jede übung. Diese Lösung macht Gebrauch von machen die builtin-Regeln, so müssen Sie nur geben Sie make e0614 und es wird erzeugen e0614.cpp kompilieren Sie und verknüpfen Sie Sie. Sie können anpassen, jeder .cpp - Datei (Sie wird nicht regeneriert werden als unten geschrieben) und warten, dass die Geschichte zu beziehen, wie Sie komplette übungen, anstatt zu löschen es, wie Sie sich bewegen von einem zum nächsten. (Sie sollte auch mit einer Versionsverwaltung, wie Mercurial.)

Makefile
```
e%.cpp:
        ./gen_ex_cpp $@ > $@
```
Können Sie generieren boilerplate-code mit scripts, weil Sie nicht wollen, es zu mühsam. Es gibt mehrere Optionen für diese Skripten—und ich verwenden eine Vielzahl von Sprachen, darunter C++, Python und shell—aber der Python unten ist kurz und sollte einfach und klar sein hier genug.

Beispiel-Skript generieren
```
#!/usr/bin/python
import sys
args = sys.argv[1:]
if not args:
  sys.exit("expected filename")
name = args.pop(0).partition(".")[0]
if args:
  sys.exit("unexpected args")
upper_name = name.upper()
print """
#include "%(name)s.hpp"
int main() {
  %(upper_name)s ex;
  ex.solve();
  return 0;
}
""" % locals()
```
Beachten Sie, dass dieses Python-Skript wächst, wird es umgestaltet, um eine main-Funktion und Verwendung der optparse (oder ähnlich) - Modul.

InformationsquelleAutor
0

Machen Sie eine master-include-Datei enthält die Namen aller Header, die Sie wollen.

Es ist eine wirklich schlechte Idee *, auch wenn Sie könnten.

Eine master-Datei nicht wirklich helfen hier. Es bedeutet nur, dass er alle Header in der master-Datei statt in main.cpp. Es könnte helfen, in anderen Fällen, aber nicht hier.

InformationsquelleAutor ddyer
0

Könnte man mit der bedingten Kompilierung für den Namen der Klasse durch Verwendung von-Verkettung.
```
//Somewhere in your other files
define CLASS_NUMBER E0614

//in main.cpp
#define ENTERCLASSNUMBER(num) \
##num## ex;

//in main()
ENTERCLASSNUMBER(CLASS_NUMBER)
```
Weiß nicht, enthält aber. Wie oben vorgeschlagen, ein script könnte die beste option sein.

InformationsquelleAutor Nathan Osman
0

schreiben Sie eine makefile-Regel übergeben Sie den Namen der ausführbaren Datei als ein -DHEADERFILE=etwas, parameter an den compiler sollte nicht schwer sein. So etwas wie:
```
%.exe : %.h %.cpp main.cpp
    gcc -o $< -DHEADER_FILE=$<F $>
```
OTOH, ich weiß nicht, ob #include keinen makro-Erweiterung auf den Dateinamen.

InformationsquelleAutor Ben Voigt
0
```
sed -i 's/\<\$[eE]\$[0-9]+\\>/\19999/' main.cpp
```
Ersetzen 9999 mit der erforderlichen Anzahl. Möglicherweise gibt es bessere Wege.

InformationsquelleAutor alvin

Warum nicht mit dem Objekt-Mechanismen ?

Können Sie eine Vorbild-Strategie.

class BaseExercise
{
public:
  static bool Add(BaseExercise* b) { Collection().push_back(b); return true; }
  static size_t Solve() {
    size_t nbErrors = 0;
    for(collections_type::const_iterator it = Collection().begin(), end = Collection().end(); it != end; ++it)
      nbErrors += it->solve();
    return nbErrors;
  }

  size_t solve() const
  {
    try {
      this->solveImpl();
      return 0;
    } catch(std::exception& e) {
      std::cout << mName << " - end - " << e.what() << std::endl;
      return 1;
    }
  }
protected:
  explicit BaseExercise(const char* name): mName(name)
  {
  }
private:
  typedef std::vector<BaseExercise*> collection_type;
  static collection_type& Collection() { collection_type MCollection; return MCollection; }

  virtual void solveImpl() const = 0;

  const char* mName;
}; //class BaseExercise

template <class T>
class BaseExerciseT: public BaseExercise
{
protected:
  explicit BaseExerciseT(const char* b): BaseExercise(b) { 
    static bool MRegistered = BaseExercise::Add(this);
  }
};

Okay, das ist die Basis.

//Exercise007.h
#include "baseExercise.h"

class Exercise007: public BaseExerciseT<Exercise007>
{
public:
  Exercise007(): BaseExerciseT<Exercise007>("Exercise007") {}
private:
  virtual void solveImpl() const { ... }
};

//Exercise007.cpp
Exercise007 gExemplar007;

Sowie für Haupt -

//main.cpp
#include "baseExercise.h"

int main(int argc, char* argv[])
{
  size_t nbErrors = BaseExercise::Solve();
  if (nbErrors) std::cout << nbErrors << " errors" << std::endl;
  return nbErrors;
}

Und hier, Sie brauchen keine Skript 😉

InformationsquelleAutor Matthieu M.

-1

versuchen Sie dies:-

#ifndef a_h
#define a_h

#include <iostream>
#include <conio.h>
#incl....as many u like
class a{
f1();//leave it blank
int d;
}
#endif //save this as a.h

später
sind diese in der ur Haupt-Programm, das cpp-Datei

#include "a.h"

...Ihr Programm

InformationsquelleAutor comfreak

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Update:

Makefile

Beispiel-Skript generieren