如何在循环中使用多维char或字符串数​​组

Question

I'm so new to C++ and I just can't figure out how to use any multidimesional arrays. I want to do something like that:

input number of product: number; //the products' name can be 7 with NULL char. (max 6)
char arr[number][7];

That works. But when I want to do that in a for loop(i):

cin>>arr[i][7];

and I don't know what the hell is compiler doing?

I just want that:

arr[0][7]=apple;
arr[1][7]=orange;

So please how can I do that?

Answer 1

#include <string>
#include <vector>

Since everybody is recommending it, I thought I'd sketch the options for you.

Note that you would have gotten this kind of answer in 10 milli-seconds by 3 different persons, if you had supplied a short, working sample code snippet (translating code 1:1 is more efficient than 'thinking up' examples that you might recognize)

Here you go:

std::vector<std::string> strings

strings.push_back("apple");    
strings.push_back("banana");

// or
std::string s;

std::cin >> s; // a word
strings.push_back(s);

// or
std::getline(std::cin, s); // a whole line
strings.push_back(s);

// or:
// add #include <iterator>
// add #include <algorithm>

std::copy(std::istream_iterator<std::string>(std::cin),
     std::istream_iterator<std::string>(),
     std::back_inserter(strings));

Direct addressing is also possible:

std::vector<std::string> strings(10); // 10 empty strings

strings[7] = "seventh";

Edit in response to comments:

const char* eighth = "eighth";

if (strings[7] != eighth)
{  
      // not equal
}

// If you really **must** (read, no you don't) you can get a const char* for the string:

const char* sz = strings[7].c_str(); // warning: 
         // invalidated when `strings[7]` is modified/destructed

Answer 2

Because arr[i][7] is a char , and in fact one past the last element, which means you may get memory access error.

What you want to do maybe cin>>arr[i]; .

How ever, this is not a very good idea, as you cannot control how many characters are read from input, which will easily cause memory overrun.

The easy way would be using std::vector<std::string> as others have suggested.

Answer 3

Unless you have a real reason (which you mustn't hide from us), make as Björn says and use a vector of strings. You can even do away with the initial request for the total size:

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

std::vector<std::string> fruits;
std::string line;

while (std::getline(std::cin, line))
{
  fruits.push_back(line);
}

Let's test:

std::cout << "You entered the following items:\n";
for (auto const & f : fruits) std::cout << "* " << f << "\n";

Answer 4

You have a two dimensional array of char

char arr[number][7];

And then trying to assign a string (char* or const char*) to them which will not work. What you can do here is assign a character, for example:

arr[0][1] = 'a';

If you can I would recommend using std::vector and std::string it would make things much clearer. In your case you could do

cin>>arr[i];

But I would not recommend it as you could only store up to 6 character char* strings (plus the null terminator). You can also have an array of char*

char* arr[number];

then dynamically allocate memory to store the strings.

Answer 5

strcpy(&arr[0], "apple");
strcpy(&arr[1], "orange");

but for C++ is better to use std::vector<std::string> for array of strings

Answer 6

Using std::vector and std::string will usually save you headaches once you understand them. Since you are brand new to C++, it might be useful to understand what is going on with two-dimensional arrays anyhow.

When you say

char array[N][M];

With N and M being constants, not variables, you are telling the compiler to allocate N*M items of type char. There will be a block of memory dedicated to that array of size N*M*sizeof(char). (You can declare an array of anything, not just char. Since sizeof(char) is 1, the memory will be N*M bytes long.) If you looked at raw memory, the first byte in the memory would be where array[0][0] is. The second byte would be where array[0][1] is, an so on, for M bytes. Then you would see array[1][0]. This is called row-major order.

As @jbat100 mentioned, when you say array[i][j] you are referring to a single character. When you say array[i], you are referring to the address of row i in the array. There is no pointer actually stored in memory, but when you say array[i] the compiler knows that you mean that you want the address of row i in the array:

char* row_i = array[i];

Now if i>0, then row_i points to somewhere in the middle of that block of memory dedicated to the array. This would do the same thing:

char* row_i = &array[i][0];

If you have a string, "orange" and you know that the length of it is less than M, you can store it in a given row in the array, like this:

strcpy(array[i], "orange"); // or
array[i][0] = 'o'; array[i][1] = 'a'; ... array[i][6] = 0;

Or you could have said row_i instead of array[i]. This copies 7 bytes into the array in the location of row_i. The strcpy() also copies an extra byte which is a 0, and this is the convention for terminating a character string in C and C++. So the 7 bytes are six bytes, 'o', 'r', 'a', 'n', 'g', and 'e', plus a 0 byte. Now strcmp(row_i, "orange") == 0.

Beware that if your string is longer than M, the strcpy and the simple char assignments will not (probably) produce a compile error, but you will end up copying part of your string into the next row.

Read about pointers and arrays in a good C/C++ book.