如何用句子填充数组？

Question

For instance i have the sentence " I am Piet". I want to fill this sentence into an array in a way that I[0], am[1] Piet[2]. Below is the code i've made. The problem is that the sentence is filled in each element of the array.

#include <iostream>
#include <string>
using namespace std;

// function to populate my array
void populateMyArray(string*myArray, string sentence, int size)
{
for (int i = 0; i < size; i++)
{
*myArray = sentence;
    myArray++;
}
}

// function to count works in the sentence
int countWords(string x)
{
int Num = 0;
char prev = ' ';

for (unsigned int i = 0; i < x.size(); i++) {

    if (x[i] != ' ' && prev == ' ') Num++;

    prev = x[i];
}
return Num;
}

int main()
{
string sentence1;

cout << "Please enter a line of text:\n";
getline(cin, sentence1);

int nWords1 = countWords(sentence1);

string *arr1 = new string[nWords1];

populateMyArray(arr1, sentence1, nWords1); //populate array1

for (int i = 0; i < nWords1; i++)
{
    cout << "sentence one: " << arr1[i] << "\n";
}

system("PAUSE");
}

Answer 1

You can use vector in order to save data and each time you should use space between two words and you will store each string type into vector array

 #include<bits/stdc++.h>
    using namespace std;
        main()
        {
            string s;
            getline(cin,s);
            vector<string> ss;
            string temp = "";
            s +=" ";
            for(int i = 0 ; i < s.size();i ++){
                if(s[i] != ' ')
                    temp += s[i];
                else{
                        ss.push_back(temp);
                        temp = "";
                }
            }
            for(int i = 0 ; i < ss.size();i ++)
                cout << ss[i] <<" ";
        }

Answer 2

Instead of using an array, use a std::vector instead. This way you don't have to worry about variable word sizes or overflowing anything in case a word or sentence is too long. Rather you can just do something like this:

#include <iostream>
#include <string>
#include <vector>
#include <sstream>

int main() {
  // Get all words on one line
  std::cout << "Enter words: " << std::flush;
  std::string sentence;
  getline(std::cin, sentence);

  // Parse words into a vector
  std::vector<std::string> words;
  std::string word;
  std::istringstream iss(sentence);
  while( iss >> word ) {
    words.push_back(word);
  }

  // Test it out.
  for(auto const& w : words) {
    std::cout << w << std::endl;
  }
}

For an example sentence of I like cats and dogs equally you will have: words[0] = I , words[1] = like and so on.

Answer 3

How to think like a programmer.

The first thing we need is definitions of the beginning or a word and the end of a word. You might think that the beginning of a word is a non-space preceded by a space and the end of a word is a non-space followed by a space. But those definitions are wrong because they ignore the possibility of words at the start or end of the string. The correct definition of the beginning of a word is a non-space at the start of the string or a non-space preceded by a space. Similarly the end of a word is a non-space at the end of the string or a non-space followed by a space.

Now we have the definitions we capture them in two functions. It's very important to break complex problems down into smallier pieces and the way to do that is by writing functions (or classes).

bool beginning_of_word(string str, int index)
{
    return str[index] != ' ' && (index == 0 || str[index - 1] == ' ');
}

bool end_of_word(string str, int index)
{
    return str[index] != ' ' && (index == str.size() - 1 || str[index + 1] == ' ');
}

Now we're getting closer, but we still need the idea of finding the next start of word, or the next end of word, so we can loop through the sentence finding each word one at a time. Here are two functions for finding the next start and next end of word. They start from a given index and find the next index that is the start or end of a word. If no such index is found they return -1.

int next_beginning_of_word(string str, int index)
{
    ++index;
    while (index < str.size())
    {
        if (beginning_of_word(str, index))
            return index; // index is a start of word so return it
        ++index;
    }
    return -1; // no next word found
}

int next_end_of_word(string str, int index)
{
    ++index;
    while (index < str.size())
    {
        if (end_of_word(str, index))
            return index; // index is an end of word so return it
        ++index;
    }
    return -1; // no next word found
}

Now we have a way of looping through the words in a sentence we're ready to write the main loop. We use substr to break the words out of the sentence, substr takes two parameters the index of the start of the word and the length of the word. We can get the length of the word by substracting the start from the end and adding one.

int populateMyArray(string* array, string sentence)
{
    // find the first word
    int start = next_beginning_of_word(sentence, -1);
    int end = next_end_of_word(sentence, -1);
    int count = 0;
    while (start >= 0) // did we find it?
    {
        // add to array
        array[count] = sentence.substr(start, end - start + 1);
        ++count;
        // find the next word
        start = next_beginning_of_word(sentence, start);
        end = next_end_of_word(sentence, end);
    }
    return count;
}

Now for extra credit we can rewrite countWords using next_beginning_of_word

int countWords(string sentence)
{
    int start = next_beginning_of_word(sentence, -1);
    int count = 0;
    while (start >= 0)
    {
        ++count;
        start = next_beginning_of_word(sentence, start);
    }
    return count;
}

Notice the similarity of the countWords and the populateMyArray functions, the loops are very similar. That should give you confidence.

This is the way programmers work, when you have a problem that is too complex for you to handle, break it down into smaller pieces.

Answer 4

If I understood correctly you are trying to split the input sentence into words.

You could do it like this:

void populateMyArray(string *myArray, string sentence, int size)
{
  int firstCharIndex = -1;
  char prev = ' ';

  for (unsigned int i = 0; i < sentence.size(); i++) {
    // Find the first character index of current word
    if (sentence[i] != ' ' && prev == ' ') {
      firstCharIndex = i;
    }
    // Check if it's the end of current word
    // and get substring from first to last index of current word
    else if (sentence[i] == ' ' && prev != ' ') {
      *myArray = sentence.substr(firstCharIndex, i - firstCharIndex);
      myArray++;
    }
    prev = sentence[i];
  }

  // For the last word
  if (firstCharIndex != -1 && sentence[sentence.size() - 1] != ' ') {
    *myArray = sentence.substr(firstCharIndex, sentence.size() - firstCharIndex);
  }
}