Issue with >2 cin commands

This is a discussion on Issue with >2 cin commands within the C++ Programming forums, part of the General Programming Boards category; I found that when I use more than two user inputs, the program will immediately exit after the third. Is ...

  1. #1
    Registered User
    Join Date
    Jun 2009
    Posts
    45

    Issue with >2 cin commands

    I found that when I use more than two user inputs, the program will immediately exit after the third.
    Is there a way I can stop this?

  2. #2
    Registered User
    Join Date
    Dec 2006
    Location
    Canada
    Posts
    3,183
    What's the code?

  3. #3
    Registered User
    Join Date
    Jun 2009
    Posts
    45
    Haha, it's about 11 KB. I'll quickly try to make an example program, because I've seen it happen before.

  4. #4
    Master Apprentice phantomotap's Avatar
    Join Date
    Jan 2008
    Posts
    4,258
    O_o

    I think we could cope with 500 lines.

    Soma

  5. #5
    Registered User
    Join Date
    Dec 2006
    Location
    Canada
    Posts
    3,183
    O_o

    I think we could cope with 500 lines.

    Soma
    No one has time for that. Make the simplest compilable program that demonstrates the problem.

  6. #6
    Registered User
    Join Date
    Jun 2009
    Posts
    45
    ...ok, just 3 cins worked fine.

    So, here's the source. I discovered the problem when using my --emulate command, I tried --format, which worked fine on its own, but here it just stopped. And I seem to recall having a simmilar issue before.

    Edit: running --emulate on any command will shut it down after you've stated your command (ex: --in), then done an input.
    Code:
    #include <iostream>
    #include <string>
    #include <vector>
    #include <stdlib.h>
    #include <fstream>
    #include <ctime>
    
    using namespace std;
    
    //Function EditPathIn
    void EditPathIn ()
    {
    string new_path_in ;  //variable
    cout << "Type the filepath of where you want back up. Be sure to end it with a / !\n";
    cin >> new_path_in ;
    ofstream path ;
    path.open (".backup_prefs/path_in") ;
    path << new_path_in ;
    path.close() ;
    }
    
    //Function EditPathOut
    void EditPathOut ()
    {
    string new_path_out ;  //variable
    cout << "Type the filepath of where you want to store your backup. Be sure to end it with a / !\n";
    cin >> new_path_out ;
    ofstream path ;
    path.open (".backup_prefs/path_out") ;
    path << new_path_out ;
    path.close() ;
    }
    
    //Function EditFormat
    void EditFormat ()
    {
    string new_format_short ;  //variable
    string new_format_full ;  //Expanded form
    cout << "Enter the letter representing the format you want to use.\n\n";
    cout << "t                   Gzipped tar (.tar.gz), for average compression.\n" ;
    cout << "z                   Zip (.zip), for low compression.\n" ;
    cout << "7                   7zip (.7z), for high compression.\n" ;
    cout << "  High compression formats take longer.\n" ;
    cin >> new_format_short ;
    if ( new_format_short == "t" ) {
      new_format_full = "tar" ;
    }
    if ( new_format_short == "z" ) {
      new_format_full = "zip" ;
    }
    if ( new_format_short == "7" ) {
      new_format_full = "7z" ;
    }
    ofstream format ;
    format.open (".backup_prefs/format") ;
    format << new_format_full ;
    format.close() ;
    //Record new format to log
    ofstream appendlog ("./.backup_prefs/log", ios::app );
    if (appendlog.is_open()) {
      appendlog << " to " ;
      appendlog << new_format_full ;
      appendlog << " at " ;
      appendlog.close();
        }
    }
    
    //Main
    int main( int argc, char** argv )
    {
    time_t now;  //Time
    struct tm *d;  //Time
    char li [13];  //Time
    vector <string> args( argv, argv+argc ) ;
    string arg_input;  //For checking -xyz type options
    int search_for_option = 0;  //WTF are fluxes?
    int multiple_formats = 0 ;
    string emulated_args = "nothing" ;
    char yesno ;  //For y/n
    string io_select ;
    int include_hidden_files = 0 ;
    int options_present = 0 ;
    string archive_type = "tar" ;
    string options_to_terminal ;
    string settings_outpath ;
    string settings_inpath ;
    string line_outpath ;
    string line_inpath ;
    string line_format ;
    string date ;  //User entered date
    string extension = ".tar.gz" ;
    string path_in = "~/" ;
    string astrisk ;  //Adds an astrisk (all) if called.
    string exclude_hidden_files = "-X .*" ;  //Excludes all .* (hidden) files
    string final_command ;
    
    
    
    
    
    Start:;  //A goto
    //Get dd-mm-yyyy
    time(&now);
    d = localtime(&now);
    strftime(li, 15, "%d-%m-%Y", d);
    date = li ;
    
    //Find preferences
    ifstream log (".backup_prefs/log");
    if (log.is_open()) {
    cout << "Found preferences directory.\n\n" ;
    }
    else {
      system ( "mkdir ~/.backup_prefs" ) ;  //Make directory (assuming that no log = no directory)
      ofstream mklog ;
      mklog.open (".backup_prefs/log") ;
      mklog << "Creating log: " ;
      mklog << date ;
      mklog << ".\n\n\n" ;
      mklog.close() ;
    }
    
    //Load preferences
    //Path in
    ifstream in(".backup_prefs/path_in") ;
    while(getline(in,line_inpath))
    path_in += line_inpath ;
    //Path out
    ifstream hi(".backup_prefs/path_out") ;
    while(getline(hi,line_outpath))
    settings_outpath += line_outpath ;
    //Format
    ifstream format(".backup_prefs/format") ;
    while(getline(format,line_format))
    archive_type = line_format ;
    
    
    
    
    
    if ( emulated_args != "nothing" ) {  //If it is an emulated run
      arg_input = emulated_args ;
    }
    if ( argv[1] && emulated_args == "nothing" ) {
      arg_input = argv[1];  //Gives string arg_input the contents of argument 1, ONLY IF there is an argument 1.
                            //Without the if, segfault.
    }
    
    //If not normal run ( backup <something else> ), check the <something else>.
    if (args.size() > 1) {
      //If --help
      if ( arg_input == "--help" ) {
    
        cout << "\n"
        "Usage: backup [option(s)/function]\n"
        "Options are written as -xyz. You can append as many options as you want.\n"
        "Functions are written as --name, and exit after running.\n\n"
        "Options:\n"
        "  -i                  Backs up user-defined location instead of default.\n"
        "  -h                  Includes hidden files .\n"
        "  -o                  Sends to user-defined location instead of default.\n"
        "  -z                  Uses .zip instead of .tar.gz . Is less efficiant, but is supported everywhere.\n"
        "  -7                  Uses .7z instead of .tar.gz . 7zip takes longer, but produces a smaller file.\n"
        "\n"
        "Functions:\n"
        "  --emulate           Treat the next input as if it was argument 1. Use backup --emulate on launchers.\n"
        "  --format            Change the default archive format.\n"
        "  --in                Edit input location.\n"
        "  --help              Opens this index.\n"
        "  --out               Edit output location.\n"
        "\n" ;
        ofstream appendlog ("./.backup_prefs/log", ios::app );
        if (appendlog.is_open()) {
          appendlog << "--help" ;
          appendlog << " at " ;
          appendlog << date ;
          appendlog << ".\n\n" ;
          appendlog.close();
        }
    goto End;  //NO NOT GOTO
              //THE VELOCIRAPTORS
      }
    
        //If --emmulate
        if ( arg_input == "--emulate" ) {
          //State emulation in log
          ofstream appendlog_emulate ("./.backup_prefs/log", ios::app );
          if (appendlog_emulate.is_open()) {
            appendlog_emulate << "Runing emulation..." ;
            appendlog_emulate.close();
          }
          cout << "backup " ;
          cin >> emulated_args ;
          options_present = 0 ;
    goto Start;
        }
    
        //If --format
        if ( arg_input == "--format" ) {
          //Outputs filepath from ~/.backup_prefs/format
            ifstream myfile (".backup_prefs/format");
            if (myfile.is_open()) {
              while (! myfile.eof() ) {
                getline (myfile,line_format);
                cout << "\n" ;
                cout << line_format ;
              }
            myfile.close();
            cout << " is your default archive format. Do you want to edit it? y/n\n" ;
            yesno=cin.get();
            cin.ignore(256,'\n');
            if ( yesno == 'y' ) {    //<-Stopped here.
              //Archive format changed from <format> ...
              ofstream appendlog_format_old ("./.backup_prefs/log", ios::app );
              if (appendlog_format_old.is_open()) {
                appendlog_format_old << "Archive format changed from " ;
                appendlog_format_old << archive_type ;
                appendlog_format_old.close();
              }
              EditFormat () ;  //Launch function
              //Record date of change to log
              ofstream appendlog_format_date ("./.backup_prefs/log", ios::app );
              if (appendlog_format_date.is_open()) {
                appendlog_format_date << date ;
                appendlog_format_date << ".\n" ;
                appendlog_format_date.close();
              }
            }
          }
          else {
            cout << "Unable to open config file. Making a new one...\n" ;
            ofstream appendlog_format_old ("./.backup_prefs/log", ios::app );
            if (appendlog_format_old.is_open()) {
              appendlog_format_old << "Archive format changed from " ;
              appendlog_format_old << archive_type ;
              appendlog_format_old.close();
            }
            EditFormat () ;
            //Record date of change to log
            ofstream appendlog ("./.backup_prefs/log", ios::app );
            if (appendlog.is_open()) {
              appendlog << date ;
              appendlog << " becuase format preference not found.\n\n" ;  //State reason
              appendlog.close();
            }
        }
    goto End;
    }
    
    
        //If --in
        if ( arg_input == "--in" ) {
          //Outputs filepath from ~/.backup_prefs/path_in
            ifstream myfile (".backup_prefs/path_in");
            if (myfile.is_open()) {
              while (! myfile.eof() ) {
                getline (myfile,line_inpath);
                cout << "\n" ;
                cout << line_inpath << endl;
              }
            myfile.close();
            cout << "This is the location that will be archived. Do you want to edit it? y/n\n" ;
            yesno=cin.get();
            cin.ignore(256,'\n');
            if ( yesno == 'y' ) {
              EditPathIn () ;
            }
          }
          else {
            cout << "You don't have a selected input location. ~/ (user's home) is used as a default, though having a saved preference is recommended.\nDo you want to make a config file? y/n " ;
            yesno=cin.get();
            cin.ignore(256,'\n');
            if ( yesno == 'y' ) {
              cout << "Making a new one...\n" ;
              EditPathIn () ;
            }
        }
    goto End;
    }
    
    
        //If --out
        if ( arg_input == "--out" ) {
          //Outputs filepath from ~/.backup_prefs/path_out
            ifstream myfile (".backup_prefs/path_out");
            if (myfile.is_open()) {
              while (! myfile.eof() ) {
                getline (myfile,line_outpath);
                cout << "\n" ;
                cout << line_outpath << endl;
              }
            myfile.close();
            cout << "This is the location that the backup will be stored. Do you want to edit it? y/n\n" ;
            yesno=cin.get();
            cin.ignore(256,'\n');
            if ( yesno == 'y' ) {
              EditPathOut () ;
            }
          }
          else {
            cout << "Unable to open config file. Making a new one...\n" ;
            EditPathOut () ;
        }
    goto End;
    }
    
    
        //If --segfault
        if (args[ 1 ] == "--segfault" ) {
          system ("firefox http://xkcd.com/371/") ;
    goto End;
        }
    
    
    
    
    
      //Checks for multiple formats
      if ((search_for_option = arg_input.find("t", 0)) && (search_for_option != string::npos) && (search_for_option = arg_input.find("t", search_for_option))) {
      multiple_formats = multiple_formats + 1 ;  //+1 if tar
      }
      if ((search_for_option = arg_input.find("z", 0)) && (search_for_option != string::npos) && (search_for_option = arg_input.find("z", search_for_option))) {
      multiple_formats = multiple_formats + 1 ;  //+1 if zip
      }
      if ((search_for_option = arg_input.find("7", 0)) && (search_for_option != string::npos) && (search_for_option = arg_input.find("7", search_for_option))) {
      multiple_formats = multiple_formats + 1 ;  //+1 if 7zip
      }
      if ( multiple_formats > 1 ) {
        cout << "Error. You've selected multiple archive types. Please only pick one.\n" ;
      }
      else {
    
        //Things that must be initialized first
        //Uh...
    
    /*    //-c
        if ((search_for_option = arg_input.find("c", 0)) && (search_for_option != string::npos) && (search_for_option = arg_input.find("c", search_for_option)) ) {
          cout << "Note: Copy does not support excluding  hidden files.\n" ;
          cout << "Do you want to use copy? y/n " ;
          yesno=cin.get();
          cin.ignore(256,'\n');
          //If y, set to copy
          if ( yesno == 'y' ) {
            archive_type = "cp" ;
            extension = "" ;
            options_present = 1 ;
          }
        }  */
    
        //-i
        if ((search_for_option = arg_input.find("i", 0)) && (search_for_option != string::npos) && (search_for_option = arg_input.find("i", search_for_option)) ) {
        cout << "Enter the location of the folder you wish to archive. Remember to end with / ! Path: " ;
        cin >> path_in ;
        cout << "Getting files from " << path_in ;
        cout << "\n" ;
        options_present = 1 ;
        }
    
        //-h
        if ((search_for_option = arg_input.find("h", 0)) && (search_for_option != string::npos) && (search_for_option = arg_input.find("h", search_for_option)) ) {
          include_hidden_files = 1 ;
          options_present = 1 ;
        }
    
        //-o
        if ((search_for_option = arg_input.find("o", 0)) && (search_for_option != string::npos) && (search_for_option = arg_input.find("o", search_for_option))) {
          cout << "Enter the location you wish to put the backup. Remember to end in / ! Note that this does not change the default location of " << settings_outpath ;
          cout << "\nLocation:" ;
          cin >> settings_outpath ;
          options_present = 1 ;
        }
    
        //-t
        if ((search_for_option = arg_input.find("t", 0)) && (search_for_option != string::npos) && (search_for_option = arg_input.find("t", search_for_option))) {
          //Confirmation
          cout << "Do you want to use .tar.gz? y/n " ;
          yesno=cin.get();
          cin.ignore(256,'\n');
          //If y, set to tar
          if ( yesno == 'y' ) {
            archive_type = "tar" ;
            options_present = 1 ;
          }
        }
    
        //-z
        if ((search_for_option = arg_input.find("z", 0)) && (search_for_option != string::npos) && (search_for_option = arg_input.find("z", search_for_option))) {
          //Warning
          cout << "\nZip format is the least efficiant method of compression. The only advantage of .zip is all modern operating systems have default support. \n" ;
          cout << "This is only a concern if you intend to open the archive while on a computer that does not have or allow you to get .tar.gz support. If your issue is not having support for tar.gz preinsalled, see http://www.gzip.org/#exe \n\n" ;
          cout << "Do you want to use .zip? y/n " ;
          yesno=cin.get();
          cin.ignore(256,'\n');
          //If y, set to zip
          if ( yesno == 'y' ) {
            archive_type = "zip" ;
            options_present = 1 ;
          }
        }
    
        //-7
        if ((search_for_option = arg_input.find("7", 0)) && (search_for_option != string::npos) && (search_for_option = arg_input.find("7", search_for_option)) ) {
          //Notice
          cout << "\nUsing 7zip will take a bit longer, but the end result will be a smaller file.\n" ;
          cout << "Do you want to use .7z? y/n " ;
          yesno=cin.get();
          cin.ignore(256,'\n');
          //If y, set to 7zip
          if ( yesno == 'y' ) {
            archive_type = "7z" ;
            options_present = 1 ;
          }
      }
    }
    //  } No need?
    }
    
    
    
    
    //If no args, run, or if options_present = 1, run
    if((args.size() <= 1) || (options_present)) {
    
      //Give attributes based on archive format
      if ( archive_type == "tar" ) {
        options_to_terminal = "-czvf" ;
        extension = ".tar.gz" ;
        exclude_hidden_files = "-x .*" ;
      }
      if ( archive_type == "zip" ) {
        options_to_terminal = "-r" ;
        extension = ".zip" ;
        astrisk = "*" ;
      }
      if ( archive_type == "7z" ) {
        options_to_terminal = "a -t7z" ;
        extension = ".7z" ;
      }
    
      //If include_hidden_files, remove the exclude command
      if ( include_hidden_files ) {
        exclude_hidden_files = "" ;  //-h
      }
      
      final_command = archive_type + " " + options_to_terminal + " " + settings_outpath + date + "_backup" + extension + " " + path_in + astrisk + " " + exclude_hidden_files ;  //Creates a .tar.gz file called mm-dd_backup .
    
      //To terminal
      system (final_command.c_str()) ;
    
    ofstream appendlog ("./.backup_prefs/log", ios::app );
    if (appendlog.is_open())
    {
      appendlog << final_command ;
      appendlog << " at " ;
      appendlog << date ;
      appendlog << ".\n" ;
      appendlog.close();
    }
    else {
      cout << "Unable to record to log.\n";
    }
    }
    
    
    
    
    End:;
    }
    Last edited by Muscovy; 07-23-2009 at 08:03 PM.

  7. #7
    Registered User
    Join Date
    Dec 2006
    Location
    Canada
    Posts
    3,183
    Well, 3 cin's SHOULD work. Your problem is most probably somewhere else.

    Just by skimming through your red code,
    Code:
    ofstream format ;
    format.open (".backup_prefs/format") ;
    format << new_format_full ;
    format.close() ;
    You are not checking the return value of open, which is bad. What if the open fails because of permission problems, path problems, not enough disk space, network offline (if it's on a network share), IO problems...?

    I see you are using is_open() for other instances, did you just forgot to do it for this one?

    Also, properly indenting the code will make it a lot easier to read.

    And do you know how your program exits? Does it crash? Have you tried using GDB? (compile with g++ -g)

  8. #8
    Registered User whiteflags's Avatar
    Join Date
    Apr 2006
    Location
    United States
    Posts
    7,700
    I'm just taking a stab in the dark here but I noticed you said exit and not crash.

    Cprogramming.com FAQ > Stop my Windows Console from disappearing everytime I run my program?

    The cin stream will leave some stuff to read occasionally (particularly newlines or things that caused it to enter a fail state). So clean up after yourself with ignore and a big number until you learn how to deal with C++ input (hint: read what the faq says about it).

  9. #9
    Registered User
    Join Date
    Dec 2006
    Location
    Canada
    Posts
    3,183
    The OP is probably using a UNIX-like OS.

    Code:
     
    system ( "mkdir ~/.backup_prefs" ) ;  //Make directory (assuming that no log = no directory)

  10. #10
    Registered User
    Join Date
    Jun 2009
    Posts
    45
    It seems my reply didn't send.
    I've never hear of checking open's return. Useful.
    As to testing, I've just tested putting outputs in and seeing what it gets to.
    I wouldn't call it a crash, since it just, open pressing y, enter, displays the next line as me@computer:~$.

    Edit: this is Ubuntu Linux, though just 'Linux' is the important part.
    Last edited by Muscovy; 07-23-2009 at 08:19 PM.

  11. #11
    Registered User
    Join Date
    Jun 2009
    Posts
    45
    Through your link I found an example for Linux ( Cprogramming.com FAQ > How do I get my program to wait for a keypress? ), but I think this is talking about making it stay when the program is completed, and has no more code to run.

  12. #12
    Registered User
    Join Date
    Jun 2009
    Posts
    45
    Testing proved it to be the yes/no if statements. hey're messing up when run with --emulate. I'll see if I can find why.

Popular pages Recent additions subscribe to a feed

Similar Threads

  1. Issue w/ Guess My Number Program
    By mkylman in forum C++ Programming
    Replies: 5
    Last Post: 08-23-2007, 01:31 AM
  2. getline(function)??
    By dac in forum C++ Programming
    Replies: 7
    Last Post: 03-10-2006, 11:42 AM
  3. 'cin' and 'scanf()' issue
    By Brain Cell in forum C++ Programming
    Replies: 4
    Last Post: 11-07-2004, 09:53 AM
  4. what are some other input commands other than cin??? (C++)
    By Unregistered in forum Game Programming
    Replies: 1
    Last Post: 06-19-2002, 06:38 PM
  5. How can I issue AT commands in VC++ ?
    By Cube in forum A Brief History of Cprogramming.com
    Replies: 1
    Last Post: 10-10-2001, 07:45 AM

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21