Comment accéder aux méthodes d'une sous-classe d'un pointeur si ces méthodes sont uniques à la sous-classe?

Allouez dynamiquement une "copie" de std :: cin en saisissant son tampon. Le stockage de la mémoire dans un std :: unique_ptr serait également idéal car vous n'auriez pas à vous soucier de la suppression manuelle du pointeur.

#include <memory>

int main(int argc, char* argv[]) {
  std::unique_ptr<std::istream> currentStream( argc == 3
    ? std::make_unique<std::ifstream>(argv[2])
    : std::make_unique<std::istream>(std::cin.rdbuf())
  );

  // will only fail when the file cannot open
  if (!currentStream) {
    std::cerr << "FILE COULD NOT BE OPENED\n";
    return 1;
  }

  std::string myLine;
  // go line by line and translate it
  while (std::getline(*currentStream, myLine)) {
    std::cout << rot13(myLine) << std::endl;
  }
}

Votre code peut être amélioré à plusieurs endroits. Je pense que le point le plus important pour l'amélioration est que vous essayez d'en faire trop dans une fonction. Votre objectif de ne pas dupliquer le code est bon, mais modulez votre approche. Déplacez le code partagé vers sa propre fonction, comme dans:

int main(int argc, const char ** argv)
{
    if (argc == 3) {
        // Handle optional file input
        std::ifstream fileStream(argv[2]);
        if (fileStream.fail()) {
            std::cerr << "FILE COULD NOT BE OPENED\n";
            return 1;
        }
        do_stuff(fileStream);
        // Keep in mind that, even though there is no C++ code here, there is something
        // important being done after the call to do_stuff. Specifically, the destructor
        // for fileStream is called, which closes the file for you.
    } else {
        do_stuff(std::cin);
    }
    return 0;
}

Cette fonction doit contenir tout ce qui est partagé entre les deux chemins de code. (J'ai changé le pointeur en référence pour que les appelants sachent immédiatement qu'un pointeur nul n'est pas acceptable.) Lorsque vous modifiez votre fonction principale pour qu'elle appelle celle-ci, vous devriez remarquer que certaines choses deviennent plus faciles. En particulier, il n'y a pas besoin d'allocation dynamique (ce qui n'entraîne aucune tentative de supprimer & cin - cela avait l'air mauvais). Vous pouvez facilement utiliser une variable locale pour votre flux de fichiers.

int main(int argc, const char ** argv)
{
    if (argc == 3) {
        // Handle optional file input
        std::ifstream fileStream(argv[2]);
        fileStream.open(argv[2]);
        if (fileStream.fail()) {
            std::cerr << "FILE COULD NOT BE OPENED\n";
            return 1;
        }
        do_stuff(fileStream);
        fileStream.close();
    } else {
        do_stuff(std::cin);
    }
    return 0;
}

En déplaçant le code commun vers une fonction distincte, vous restez dans votre if code > clause. Il n'est pas nécessaire de déduire si * currentStream doit être fermé ou non, puisque vous n'avez jamais quitté la branche de code qui a créé le fichier.

Il y a un autre endroit où vous pourriez simplifier les choses. N'appelez pas open et close . Vous utilisez le constructeur ifstream qui prend un nom de fichier, donc le constructeur appelle déjà open pour vous. (Lorsque vous appelez explicitement open , vous dites à l'ordinateur de fermer le fichier et de le rouvrir .) De même, le destructeur appellera close code > pour vous; c'est un point clé de RAII . p>

Se débarrasser des appels inutiles laisse:

void do_stuff(std::istream & currentStream)
{
    std::string myLine;
    // go line by line and translate it
    while (getline(currentStream, myLine)) {
        if (currentStream.eof()) {
            break;
        }
        std::cout << rot13(myLine) << std::endl;
    }
}

Extrayez simplement une méthode:

void process(std::istream is) {
    string myLine;
    // go line by line and translate it
    while (getline(is, myLine))
        cout << rot13(myLine) << endl;
}

int main(int argc, char** argv) {
    if (argc == 3) {
        ifstream ifs(argv[2]);
        if (!ifs) {
            cerr << "FILE COULD NOT BE OPENED\n";
            return 1;
        }
        process(ifs);
    } else {
        process(cin);
    }
}