Comment compiler un projet C avec plus d'une fonction principale?

Ce que vous essayez de faire avec les multiples main fonctions?

si vous essayez de compiler plusieurs programmes différents à la fois, vous devez compiler chacun séparément (C.-à-d. un seul main par programme).

Si vous essayez de compiler un programme et que vous voulez les multiples main fonctions exécuter, vous ne pouvez pas. Vous devez spécifier un seul main et renommer les autres en quelque chose d'autre (et les appeler du simple main dans l'ordre que vous voulez).

Si vous essayez d'utiliser un seul de l' main fonctionne comme le point d'entrée unique de votre programme et ignore les autres, alors vous ne devriez pas inclure les fichiers avec l'autre main s lorsque vous liez. Je suggère de placer chaque main dans un fichier distinct, si vous voulez les garder, et seulement l'un de ces fichiers lorsque vous liez/compiler.

Si vous obtenez cette erreur par erreur, alors vous êtes probablement faire quelque chose faux avec le projet dans votre IDE. Peut-être essayez-vous accidentellement de compiler plusieurs programmes différents en un seul? Vous pourriez avoir besoin de spécifier chaque fichier contenant un main comme produit de construction séparé. C n'est pas comme Java où vous pouvez mettre un main méthode à l'intérieur de chaque classe et de spécifier l'un à l'appel, l' main en C est un nom global.

vous ne pouvez pas avoir plus d'un point d'entrée dans votre demande. Lorsque l'exécutable final est lancé, le fonction de point d'entrée (principale) est appelée. Et celui-ci ne peut pas être ambiguë.

Donc si vous voulez les appeler un par un que vous pourriez chaîne comme ceci:

void main1() {} /* Note that these aren't called main. */
void main2() {}
...

int main(int argc, char* argv[]) {
    main1();
    main2();
    return 0;
}

vous pouvez même les appeler en utilisant des threads (par exemple boost.Thread), de sorte qu'ils fonctionnent en parallèle. Mais vous ne pouvez pas avoir plusieurs fonctions nommémainlié ainsi.

si vous voulez plutôt qu'ils soient des programmes séparés chacun, vous devrez les lier séparément.

Chaque programme doit avoir exactement une fonction principale. Cependant, main peut appeler n'importe quelle fonction que vous voulez (y compris elle-même, bien que cela puisse être déroutant). Ainsi, vous devez décomposer le programme en parties logiques.

Comme beaucoup l'ont dit, vous ne pouvez avoir qu'un principal par programme. Vous ne voulez pas passer par le tracas de créer un nouveau projet pour chaque exemple que vous parcourez un livre. C'est compréhensible, mais tu devras faire ça. Je vois deux solutions:

1. utilisez la nouvelle fonction de projet dans votre IDE (comme VS2010). Cela va faire tout le travail dur pour vous. Vous pouvez toujours les effacer plus tard.
2. si vous ne vous souciez pas de garder le code autour, juste vider le file (ou même la fonction main ()) et réutilisez-la. Avec des exemples de livres, vous ne revisiterez probablement jamais le code de toute façon, donc juste la suppression devrait être très bien.

vous pouvez avoir plus d'une main dans le même projet, si à chaque main correspond un exécutable différent dans l'arborescence du répertoire de compilation.

l'exemple suivant est L'utilisation de CMake, Je ne sais pas si cela peut être fait avec d'autres logiciels de gestionnaire de processus de construction.

conservez les deux suivants .rpc fichiers dans un dossier nommé source, et le nom de leur square_root.rpc, et power_of_two.rpc:

square_root.rpc:

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

int main (int argc, char *argv[])
{

  if (argc < 2) {
    fprintf(stdout,"Usage: %s number\n",argv[0]);
    return 1;
  }

  double inputValue = atof(argv[1]);
  double outputValue = sqrt(inputValue);
  fprintf(stdout,"The square root of %g is %g\n",
          inputValue, outputValue);

  return 0;
}

power_of_two.rpc:

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

int main (int argc, char *argv[])

{
  if (argc < 2) {
      fprintf(stdout,"Usage: %s number\n",argv[0]);
      return 1;
  }

  double inputValue = atof(argv[1]);
  double outputValue = inputValue*inputValue;

  fprintf(stdout,"The power of two of %g is %g\n",
          inputValue, outputValue);

  return 0;
}

notez qu'ils contiennent tous deux une méthode main. Puis, dans le même dossier, ajouter un .txt appelé CmakeLists.txt: il va indiquer au compilateur le nombre d'exécutable, comment les appeler et où trouver les main(s).

CmakeLists.txt:

cmake_minimum_required (VERSION 2.6)
project (Square_and_Power)
add_executable(Square2 square_root.cpp)
add_executable(Power2 power_of_two.cpp)

créer un nouveau dossier appelé build dans la même racine du source, puis utiliser cmake pour coufigurer et générer. Jetez un oeil à la structure de dossier créé dans le dossier build. Ouvrez un terminal dans le build et tapez .

 →  make
[ 50%] Built target Power2
Scanning dependencies of target Square2
[ 75%] Building CXX object CMakeFiles/Square2.dir/square_root.cpp.o
[100%] Linking CXX executable Square2
[100%] Built target Square2

Si aucune erreur ne se produit, vous aurez deux exécutables: Square2 et Power2.

→  ./Square2 5
The square root of 5 is 2.23607
 →  ./Power2 5
The power of two of 5 is 25

donc vous avez le même projet avec deux réseaux qui ont compilé deux applications différentes. Les deux fichiers cpp peuvent alors partager le même en-tête et des méthodes supplémentaires dans autre .rpc ou .h les fichiers dans le projet. Je suggère de jeter un oeil aussi bien à la tutorial cmakehttps://cmake.org/cmake-tutorial/ Il peut y avoir d'autres méthodes pour obtenir des résultats similaires, sinon identiques, mais je n'en connais aucune. Espérons que d'autres utilisateurs pourront contribuer à ce fil!

je suppose qu'un de vos IDEs crée automatiquement un fichier avec un main fonction. Vérifiez autour pour voir si un a déjà été créé.

vous ne pouvez pas avoir plusieurs définitions de main. La fonction" principale " définit essentiellement ce que votre programme fait. Si vous aviez plus d'une copie de main, laquelle serait exécutée?

la solution à votre problème est d'utiliser des bibliothèques; si vous voulez réutiliser des fonctionnalités, alors vous devez créer une bibliothèque, qui est fondamentalement identique à un programme sauf que bien qu'elle ait des fonctions et des données (comme un programme), elle n'a pas de fonction spéciale appelée "main", et n'a donc pas de" point d'entrée " où l'exécution devrait commencer alors qu'elle serait double-cliquée ou chargée par le système D'exploitation. Les bibliothèques sont disponibles en deux versions: partagée/dynamique et statique. Soit l'on devrait faire. Chaque programme que vous créez aura sa propre fonction principale, mais vous pouvez réutiliser votre bibliothèque sans problèmes dans les différents programmes.

maintenant l'élément pratique de la création d'une bibliothèque... voir mon C++ De La Bibliothèque De Modèle De Projet.

Comme d'autres l'ont dit, votre projet ne peut avoir qu'une seule fonction principale.

pourquoi essayez-vous d'avoir plus d'une fonction principale? Est-ce parce que vous mettez plusieurs petits programmes d'exemple dans un projet et chacun d'eux a une main? Si c'est le cas, vous devrez peut-être créer un projet séparé pour chaque exemple afin que votre IDE ne demande pas au compilateur de compiler/lier la source à partir de plusieurs exemples dans un seul programme. Votre IDE pourrait également soutenir un concept comme un target, qui vous permet de garder le code pour plusieurs, programmes liés dans un projet et de choisir quel programme (cible) à réellement construire. L'IDE compilera alors / liera uniquement les fichiers de cette cible.

essayez d'utiliser un mot-clé statique par exemple:

fichier1.rpc:

#ifdef RUN_FILE1
#define STATIC static
#else
#define STATIC
#endif

int STATIC main(int argc, char **argv(){}

fichier2.rpc:

#ifdef RUN_FILE2
#define STATIC static
#else
#define STATIC
#endif

int STATIC main(int argc, char **argv(){}

pour la compilation ajouter /DRUN_FILE2 ou /DRUN_FILE1.

Juste une idée.

si vous utilisez MS linker, utilisez l'option / FORCE:MULTIPLE linker. Le premier symbole principal rencontré gagnera. Pas sûr que l'option est pour les autres linkers.

Pour l'apprentissage et l'expérimentation, il serait agréable d'être en mesure d'avoir plusieurs réseau pour la facilité d'utilisation, cependant, comme expliqué précédemment, vous ne pouvez avoir qu'un principal parce que c'est ainsi qu'un projet est défini dans QTcreator / .pro qmake files.

Vous pouvez créer plusieurs cibles dans les fichiers pro ou make / CMAKE.

mais pour les tests j'ai fait ça dans le .pro file pour le projet.

MAIN = simpletree_test.c

SOURCES += \
    $$MAIN \
    simpletree.c \
    graph_tree.c \
    redblacktreenode.c \
    redblacktree.c \
    redblack.c \
    pointers.c

HEADERS += \
    simpletree.h \
    graph_tree.h \
    redblacktreenode.h \
    redblacktree.h \
    redblack.h \
    pointer_manipulator.h

message("The project contains the following files:")
message($$SOURCES)

alors j'échange simplement le nom du fichier principal dans la variable appelée MAIN dans le fichier pro. l'utiliser dans la variable SOURCES.

Comme vous pouvez le voir j'ai tester plusieurs implémentations d'arbres. En ce moment je teste une variation simple des arbres où je teste une nouvelle implémentation pour trouver un noeud spécifique, avant de les tester sur l'arbre équilibré.

La méthode est cependant pas parfait, puisque vous ne avez même les noms de fonctions, etc. Et après j'ai peut être difficile à venir avec de nouveaux noms pour find_node() ou traverse_tree()

dans QtCreator, vous pouvez faire un clic droit sur un fichier et sélectionner l'option "compiler", qui ne compile que le fichier sélectionné, et les dépendances requises. Donc si vous compilez un de vos fichiers principaux comme celui-ci et que ce fichier n'inclut aucun autre fichier principal, cela devrait fonctionner.

La meilleure solution que j'ai pu trouver sur Eclipse créer des projets à chaque fois pour exécuter un seul fichier? il y a des solutions de rechange à la création d'un nouveau projet pour chaque programme.