So i have this text file which basically has 2 columns of letters and numbers separated spaces. I want to split these 2 columns and place them in separate arrays.
I tried using the getLine method with space as the delimiter but I am only able to place them in the same array. I can do this with fileOpen.eof method but that causes too many problems in my program
while(getline(openFile, letters, ' ')){
index++;
lettersArray[index] = letters;
}
I expect the output of lettersArray[index] to be a column of letters only.
I think you are using the getline function in the wrong way. Take a look at how it works here: http://www.cplusplus.com/reference/string/string/getline/
You are basically telling the getline function to use the space character to use as the delimiter. So it is processing the letters in the file in the odd numbered iterations of the while loop and the numbers in the file in the even numbered iterations of the while loop.
If you want to stick to using the getline function, here is a possible modification to make it work.
while(getline(openFile, letters, ' ')){
index++;
lettersArray[index] = letters;
getline(openFile, letters);
}
The call to the getline function on the last line of the while loop, gets rid of the remaining part of the current line.
The question is like: Remove lines that is shorter than 5 characters before the # using Notepad++
But it differs a bit...
I have like that:
abc:123
abc:1234
abc:12345
PLEASE NOTE: abc is not on all the lines, it is just an example.
I want to remove the first line in the previous example because 123 which is after : is shorter than or not equal to 5 characters.
Any help would be appreciated.
Thanks!
Open Notepad++ find and replace choose regex mode in the search and place ^((?!.+:\d{5,}).)*$ in search and keep replace with blank and press replaceAll
^((?!.+:\d{5,}).)*$
Without knowing the language there is only so much help I can offer. I'll give you an example of how I would solve this problem in C#.
Start by creating a string for your updated file (without the short lines)
string content = "";
Read a line in from your file.
Then get a substring of the line you read in - the abc: portion and check the length.
line = line.substring(indexof(":"), length - indexof(":"))
if(line.length > 5)
{
content += line;
}
At the end, truncate your file and write content to it.
it's a c++ question.
char str[10];
while(cin.get(str,10).get())
...
cin.clear();
i hope when i give just the enter key, the while loop would end due to that the cin.get(str,size) would fail encountering the blank line. but when I add a .get() behind aim to read up the following \n, the while loop just keep looping when i give a blank line?
is it that the .get() causes the judgement true override the cin.get(str,size)'s false?
cin.get(str,10) Extracts characters from the stream and stores them in str as a c-string, until either 9 characters have been extracted or the delimiting character is encountered, not "gets 10 and fails if it cant, because the line ended."
This will basically never "fail" until you get to the end of file.
You will have to capture the line and test its length separately (probably not in the same expression)
I have a code with the following snippet:
std::string input;
while(std::getline(std::cin, input))
{
//some read only processing with input
}
When I run the program code, I redirect stdin input through the file in.txt (which was created using gedit), and it contains:
ABCD
DEFG
HIJK
Each of the above lines end with one newline in the file in.txt.
The problem I am facing is, after the while loop runs for 3 times (for each line), the program control does not move forward and is stuck. My question is why is this happening and what can I do to resolve the problem?
Some clarification:
I want to be able to run the program from the command line as such:
$ gcc program.cc -o out
$ ./out < in.txt
Additional Information:
I did some debugging and found that the while loop actually is running for 4 times (the fourth time with input as empty string). This is causing the loop to program to stall, because the //some processing read only with input is unable to do its work.
So my refined question:
1) Why is the 4th loop running at all?
Rationale behind having std::getline() in the while loop's condition
must be that, when getline() cannot read any more input, it returns
zero and hence the while loop breaks.
Contrary to that, while loop
instead continues with an empty string! Why then have getline in the
while loop condition at all? Isn't that bad design?
2) How do I ensure that the while doesn't run for the 4th time without using break statements?
For now I have used a break statement and string stream as follows:
std::string input;
char temp;
while(std::getline(std::cin, input))
{
std::istringstream iss(input);
if (!(iss >>temp))
{
break;
}
//some read only processing with input
}
But clearly there has to be a more elegant way.
Contrary to DeadMG's answer, I believe the problem is with the contents of your input file, not with your expectation about the behavior of the newline character.
UPDATE : Now that I've had a chance to play with gedit, I think I see what caused the problem. gedit apparently is designed to make it difficult to create a file without a newline on the last line (which is sensible behavior). If you open gedit and type three lines of input, typing Enter at the end of each line, then save the file, it will actually create a 4-line file, with the 4th line empty. The complete contents of the file, using your example, would then be "ABCD\nEFGH\nIJKL\n\n". To avoid creating that extra empty line, just don't type Enter at the end of the last line; gedit will provide the required newline character for you.
(As a special case, if you don't enter anything at all, gedit will create an empty file.)
Note this important distinction: In gedit, typing Enter creates a new line. In a text file stored on disk, a newline character (LF, '\n') denotes the end of the current line.
Text file representations vary from system to system. The most common representations for an end-of-line marker are a single ASCII LF (newline) character (Unix, Linux, and similar systems), and as sequence of two characters, CR and LF (MS Windows). I'll assume the Unix-like representation here. (UPDATE: In a comment, you said you're using Ubuntu 12.04 and gcc 4.6.3, so text files should definitely be in the Unix-style format.)
I just wrote the following program based on the code in your question:
#include <iostream>
#include <string>
int main() {
std::string input;
int line_number = 0;
while(std::getline(std::cin, input))
{
line_number ++;
std::cout << "line " << line_number
<< ", input = \"" << input << "\"\n";
}
}
and I created a 3-line text file in.txt:
ABCD
EFGH
IJHL
In the file in.txt each line is terminated by a single newline character.
Here's the output I get:
$ cat in.txt
ABCD
EFGH
IJHL
$ g++ c.cpp -o c
$ ./c < in.txt
line 1, input = "ABCD"
line 2, input = "EFGH"
line 3, input = "IJHL"
$
The final newline at the very end of the file does not start a newline, it merely marks the end of the current line. (A text file that doesn't end with a newline character might not even be valid, depending on the system.)
I can get the behavior you describe if I add a second newline character to the end of in.txt:
$ echo '' >> in.txt
$ cat in.txt
ABCD
EFGH
IJHL
$ ./c < in.txt
line 1, input = "ABCD"
line 2, input = "EFGH"
line 3, input = "IJHL"
line 4, input = ""
$
The program sees an empty line at the end of the input file because there's an empty line at the end of the input file.
If you examine the contents of in.txt, you'll find two newline (LF) characters at the very end, one to mark the end of the third line, and one to mark the end of the (empty) fourth line. (Or if it's a Windows-format text file, you'll find a CR-LF-CR-LF sequence at the very end of the file.)
If your code doesn't deal properly with empty lines, then you should either ensure that it doesn't receive any empty lines on its input, or, better, modify it so it handles empty lines correctly. How should it handle empty lines? That depends on what the program is required to do, and it's probably entirely up to you. You can silently skip empty lines:
if (input != "") {
// process line
}
or you can treat an empty line as an error:
if (input == "") {
// error handling code
}
or you can treat empty lines as valid data.
In any case, you should decide exactly how you want to handle empty lines.
Why is the 4th loop running at all?
Because the text input contains four lines.
The new line character means just that- "Start a new line". It does not mean "The preceeding line is complete", and in this test, the difference between those two semantics is revealed. So we have
1. ABCD
2. DEFG
3. HIJK
4.
The newline character at the end of the third line begins a new line- just like it should do and exactly like its name says it will. The fact that that line is empty is why you get back an empty string. If you want to avoid it, trim the newline at the end of the third line, or, simply special-case if (input == "") break;.
The problem has nothing to do with your code, and lies in your faulty expectation of the behaviour of the newline character.
Finale:
Edit: Please read the accepted answer for the correct explanation of the problem and the solution as well.
As a note to people using std::getline() in their while loop condition, remember to check if it's an empty string inside the loop and break accordingly, like this:
string input;
while(std::getline(std::cin, input))
{
if(input = "")
break;
//some read only processing with input
}
My suggestion: Don't have std::getline() in the while loop condition at all. Rather use std::cin like this:
while(std::cin>>a>>b)
{
//loop body
}
This way extra checking for empty string will not be required and code design is better.
The latter method mentioned above negates the explicit checking of an empty string (However, it is always better to do as much explicit checking as possible on the format of the input).
This seems like a really simple question, but I can't find the answer anywhere. If I'm parsing a file (that includes newline characters) character by character, using
char next = file.get();
will the following check ever be true?
if (next == '\n')
Yes. It gets the next character from the stream. It does not skip newlines or whitespace.