Quote:Original post by Aprosenf
*** Source Snippet Removed ***

Quote:Original post by D_a_M_a_G_e_D
Why don't you try to use C commands in your C++ program.

//Example.

#include <iostream.h>
#include <stdio.h>

void main(void)
{
char* String[1024];
int Number = 0;

FILE *File = fopen("AFile", "r");

fscanf("%s %d %f", &String, &Number, &Float);

fclose(File);
}

With the C commands you can say what you expect to read.

Say you want to read a line like this:

1024 512.00 TakeItToTheHead.

the command for this is:

fscanf("%d %f %s", &varInteger, &varfloat, &varString);


Find more about this commands its easy and you have good results.
Good luck.

• #include <iostream.h>
  This is a non-standard (actually pre-standard) header. You should be using #include <iostream> (no .h). This is the standardised iostream header and places symbols in namespace std.


• #include <stdio.h>
  Likewise in C++ this header is spelt cstdio. Again, this puts the symbols in namespace std.


• void main(void)
  The main function is required in C++ to have a return type of int. The void parameter list is a C-ism. It is valid C++, but un-idiomatic. In C, functions with empty parameters were allowed to take arbitrary numbers of parameters. Only if a parameter list was void did the function take strictly no parameters. In C++ a function with an empty parameter list takes strictly no parameters.


• char* String[1024];
  In C++ you use a std::string for text unless you have good reason not to. This protects you against several issues, such as buffer overruns, forgetting to null-terminate strings and the unusual problem you've just demonstrated whereby you declared an array of 1024 uninitialised char *s, not a single stack based array of 1024 characters.


• FILE *File = fopen("AFile", "r");
  In C++ it is idiomatic to use streams. They have many advantages over C FILE *s and few disadvantages


• fscanf("%s %d %f", &String, &Number, &Float);
  How can I fail thee? Let me count the ways. If the string is longer than the buffer &String passed then the behaviour is undefined. If any of the parameters does not match the type listed in the format string the behaviour is undefined. If you provide too few target arguments the behvaiour is undefined. If any conversion specification is invalid the behaviour is undefined. If the input does not match the format string then the state of the FILE stream is left partway through parsing. The return value must be checked to see how many arguments were successfully parsed.
  
  The C++ alternative to this (with no error handling) is:
  std::string String;
  int Number;
  float Float;
  std::ifstream stream(filename);
  stream >> String >> Number >> Float;
  How many ways can this fail? Well, beyond the having the file not exist or not accessible, or malformed, pretty-much none. And all of those erros are well defined are easily detected and leave the program in a valid and easily recoverable state.


• fclose(File);
  Of course, in C one must remember to close ones FILE streams. In C++ this is unneccessary. The ifstream destructor is automatically called at end of scope and closes the stream.

Quote:Original post by Joni-Matti
Just call
infile >> ws;
before calling getline.

With this you can read the end-line chars and spaces away without storing them.

Quote:Original post by Enigma
Oh man! Don't let Zahlman see that code. Lets have a look at whats wrong with it, shall we?

Quote:

Quote:Original post by Joni-Matti
Just call
infile >> ws;
before calling getline.

With this you can read the end-line chars and spaces away without storing them.

This is a good suggestion. If leading spaces are required to be retained on the string line the idiomatic alternative is to call stream.ignore(std::numeric_limits< std::streamsize >::max(), '\n'); after reading the integers to ignore the rest of the line.

Enigma