Créer des objects dans des instructions c ++ conditionnelles

J’apprends c ++ et je viens juste de passer au chapitre orienté object. J’ai une question sur la création d’objects à l’intérieur des instructions if.

Le problème sur lequel je travaille est de créer une classe qui affichera un en-tête de rapport. La classe a un constructeur par défaut qui définit le nom de la société et le nom du rapport sur un object générique et, si l’utilisateur le souhaite, un constructeur qui prend deux arguments (nom de société et nom du rapport sous forme de chaîne).

Le problème dit spécifiquement: “Un constructeur par défaut à deux parameters devrait permettre de spécifier ces [noms de société et de rapport] lors de la création d’un nouvel object Report. Si l’utilisateur crée un object Report sans passer d’argument, utilisez la valeur par défaut Sinon, utilisez les valeurs spécifiées par l’utilisateur pour les noms. ”

Ma question est donc: comment créer ces objects? Je comprends comment créer un object sans aucun argument (par exemple, Report newobj;), mais aussi avec des arguments (par exemple, Report newobj (ssortingng ssortingng);). En gros, je sais comment créer ces objects au début de ma fonction principale. Mais est-il possible de les créer à l’intérieur si des déclarations basées sur les choix de l’utilisateur? Voici ce que j’ai jusqu’à présent et, évidemment, cela ne fonctionne pas:

#include  #include  #include "report.h" using namespace std; bool enter_company_name(); // return true if user wants to enter company name bool print_form(); // return true if user wants to print in formatted output int main() { ssortingng company_name, report_name; bool name = false, format = false; name = enter_company_name(); format = print_form(); if (name) { cout << "Enter company name: "; getline(cin, company_name); cout << "Enter report name: "; getline(cin, report_name); Report header(company_name, report_name); // THIS IS MY PROBLEM } else Report header; // THIS IS MY PROBLEM if (format) header.print_formatted(); else header.print_one_line(); return 0; } bool enter_company_name() { char choice; cout <"; cin >> choice; if (choice == 'y' || choice == 'Y') return true; else return false; } bool print_form() { char choice; cout <"; cin >> choice; if (choice == 'y' || choice == 'Y') return true; else return false; }

Je souhaite donc créer un object à l’aide de valeurs par défaut si aucune n’est spécifiée, ou en créer un avec les valeurs de l’utilisateur si tel est le choix donné. Je n’arrive pas à comprendre comment le faire de manière interactive en c ++. Je n’ai pu trouver aucune question similaire à ce jour.

La chose la plus proche que j’ai rencontrée utilise des pointeurs pour faire quelque chose de similaire à ce que je veux faire, mais le livre que j’utilise n’a pas encore reçu de pointeurs, et je veux essayer de trouver un moyen de le faire qui rest dans les limites du chapitre dans lequel je travaille (c’est-à-dire ne pas utiliser de pointeurs).

Je n’ai pas inclus le fichier d’en-tête ou le fichier d’implémentation de la classe, car je ne pense pas qu’ils soient pertinents ici.

Merci d’avance!

Je ne sais pas si j’ai bien compris votre question, mais ne pouvez-vous pas simplement déclarer le rapport avant le bloc if / else puis l’initialiser à l’intérieur?

 Report header; if (...) { header = Report(); else header = Report(name,company);

Ou de manière plus courte:

 Report header; // calls default constructor if (shouldInitializeWithParams) { header = Report(name,company); }

Bien sûr, cela nécessite que le constructeur vide soit défini.

Tout d’abord, vous ne pouvez pas créer un object dans une instruction conditionnelle et l’utiliser après l’instruction conditionnelle: les deux twigs de l’instruction conditionnelle créent une scope chacune, ainsi que tout object créé dans celle-ci détruite à la fin de la twig. En d’autres termes, vous devez proposer une approche différente. L’approche la plus simple consiste probablement à déléguer la création de l’object à une fonction qui renvoie les objects comme il convient:

 Report makeReport() { if (enter_company_name()) { ... return Report(name, company); } return Report(); } ... Report report = makeReport();

Une autre approche consiste à utiliser l’opérateur ternaire pour créer le Report une manière ou d’une autre:

 bool get_company_name = enter_company_name(); std::ssortingng name(get_company_name? read_name(): ""); std::ssortingng company(get_company_name? read_company(): ""); Report report = get_company_name? Report(name, company): Report();

Toutes ces approches supposent que la classe Report est réellement copiable.

Nous ne soaps pas si class Report est copiable, il est donc préférable d’utiliser des pointeurs.

 Report * header; if (...) { header = new Report(); else header = new Report(name,company); // after all don't forget delete header;

et bien sûr, vous devriez utiliser un pointeur d’en- header comme ça

 header->print_formatted();

La chose la plus simple qui me vienne à l’esprit est de procéder à une petite refactorisation du stream de code. Créez une fonction qui traite l’entrée et renvoie l’object construit:

 Report loadReport() { if (user_input()) { // read input return Report(name,company); } else { return Report(); } }

Puis appelez la fonction depuis main. Le petit changement dans la conception consiste en l’introduction d’une fonction dont la seule responsabilité est de créer un Report partir d’une entrée utilisateur, ce qui a du sens en tant que fonction.

Je ne suis pas sûr d’avoir bien compris votre question. Toutes mes excuses si vous lisez la réponse et réalisez que c’est le cas.

Mais néanmoins, je pense que la stratégie principale serait d’utiliser la surcharge de constructeur. c’est-à-dire que vous définissez des constructeurs pour les deux: le cas où aucun paramètre n’est transmis et le cas où les parameters sont transmis. Le premier (ce que vous appelez le constructeur par défaut) initialisera la société et rapportera les noms aux valeurs par défaut. Ce dernier atsortingbuera les parameters reçus, à la société et aux noms de rapport.

En ce qui concerne l’utilisation de pointeurs: vous pouvez l’éviter en “déclarant” beaucoup d’objects de type “Report” (classe). Par exemple, vous pouvez créer un tableau d’en-tête (objects). Et vous pouvez ensuite le définir au fur et à mesure que l’utilisateur répond.

Mais en utilisant des pointeurs, vous faites tout au runtime (affectation dynamic) alors que lorsque vous utilisez des tableaux (ou déclarez de nombreux objects): le montant est fixe. Cela peut être inefficace.