C++ ce code si je mets une classe après la fonction main()

Je suis de regarder des didacticiels vidéo sur le C++ et je sais que vous devez définir une fonction /classe avant de l'utiliser ou de l'appelé. Mais j'aime bien avoir ma fonction main() en haut, et tout le reste au-dessous de la fonction principale. Je sais que si je définis une fonction en dessous de la fonction principale, je dois le déclarer avant de l'utiliser, mais qu'une classe? De quoi ai-je besoin de le mettre au-dessus de ma fonction principale d'utiliser ma classe en dessous de la fonction principale.

#include <iostream>
using namespace std;

int main()
{
    ClassOne one;
    one.coolSaying();
    return 0;
}

class ClassOne
{
    public:
        void coolSaying()
        {
            cout << "Cool stuff yo!" << endl;
        }
};

J'ai essayé de définir ma classe en plaçant ce droit avant le main():

class ClassOne;

mais ça ne fonctionne pas.

Vous avez besoin de mettre la définition de la classe au-dessus de main(). Ou dans un fichier d'en-tête inclus avant main().
Comment dois-je procéder? J'ai essayé de classe ClassOne; à droite avant le main()
Ce serait une déclaration anticipée, et non une définition. Amende pour déclarer des pointeurs ou des références, pas d'amende pour, en fait, à l'aide des instances de cette classe.
C'est une déclaration. Vous avez besoin de placer tout ce que vous avez actuellement après la main, avant de la main.

OriginalL'auteur Vince | 2013-08-04

  1. 5

    C'est pourquoi les fichiers d'en-tête sont normalement utilisées en C++. Lorsque vous êtes en train de dire ClassOne one, le compilateur doit savoir ce qu'est la classe ressemble à créer un objet de ce type. Il ne suffit pas de savoir que la classe existe quelque part (ce qui est suffisant si tout ce que vous voulez, c'est un pointeur). Ainsi, le compilateur doit déjà avoir lu la définition de la classe.

    Votre classe doit être définie avant sa première utilisation. Sans le mettre explicitement avant main, de la manière habituelle est de créer un fichier d'en-tête. Ainsi, vous créez ClassOne.h avec la déclaration de la classe, et que vous avez #include "ClassOne.h en haut de votre fichier. Dans cette situation, les méthodes de la classe devrait normalement être dans un autre fichier source, ClassOne.cpp.

    C'est ce que j'ai fait après plus de connaissance de C++ Merci 🙂

    OriginalL'auteur DUman

  2. 2

    Une classe DOIT être "complète" lorsque vous créez une instance de celle-ci. Donc, il n'y a aucun moyen que vous pouvez utiliser la classe avant de vous avez défini le contenu entier de la classe.

    Il est possible de faire quelque chose comme ceci:

    class ClassOne;
ClassOne* make_class_one();
void use_class(ClassOne *x);

int main()
{
    ClassOne* one = make_class_one();

    use_class(one);
    return 0;
}


class ClassOne
{
    public:
        void coolSaying()
        {
            cout << "Cool stuff yo!" << endl;
        }
};

ClassOne* make_class_one()
{
     return new ClassOne;   //Bad idea, use uniqe_ptr, but I'm lazy.
}

void use_class(ClassOne *x)
{
    x->coolSaying();
}

    Mais en général, nous ne voulons pas le faire.

    OriginalL'auteur Mats Petersson

  3. 1

    Un scénario où la définition de la classe après la fonction main() prend tout son sens:

    #include <iostream>
using namespace std;

void f();

int main()
{
    f();
    return 0;
}

class ClassOne
{
    public:
        void coolSaying()
        {
            cout << "Cool stuff yo!" << endl;
        }
};

void f()
{
    ClassOne one;
    one.coolSaying();
}

    OriginalL'auteur Lior Kogan

  4. 1

    (remarque: toutes les autres réponses sont correctes, mais vous pouvez trouver cela utile)

    J'ai découvert cet idiome d'inverser l'ordre des main et secondaire en fonction des classes. J'utilise de partage de code avec des collègues, tout le monde s'attend à ce que la base de code (c'est à dire main) à être sur le dessus de sorte qu'ils peuvent modifier rapidement. Il travaille avec des classes et des fonctions (sans besoin de déclaration) de cours. Habituellement, je peux laisser le préambule (première #includes) parce que ceux qui ont des gardes dans la plupart des cas.

    #include <iostream>
using namespace std;

#ifdef please_see_definitions_below_main
int main()
{
    ClassOne one;
    one.coolSaying();
    return 0;
}
#else
class ClassOne
{
    public:
        void coolSaying()
        {
            cout << "Cool stuff yo!" << endl;
        }
};
#define please_see_definitions_below_main
#include __FILE__
#endif

    - Je utiliser la balise please_see_definitions_below_main de sorte qu'il sert de commentaire aussi, mais si vous ne l'aimez pas, vous pouvez utiliser quelque chose de plus court, comme AFTER.

    OriginalL'auteur alfC

  5. 0

    Vous ne pouvez pas créer une réelle instance du type (variable, valeur membre) jusqu'à ce que le type est complètement définis, de même que sa taille n'est pas connue. Il n'y a pas moyen de contourner cela, mais il ya beaucoup que vous pouvez déjà faire avec un pointeur vers un type incomplète.

    OriginalL'auteur fatihk