A simple Array issue

[TastySauceCode]

Hey there, I'm fairly new to C++ so please bear with me as I almost insult your intelligence with this simple question

 char *nu_array[] = {"HELLO", "WORLD"};

   char **p = nu_array;

   for(int i = 0; i != 6; i++ ){

       cout << *(*p + i) << endl;

I've first created an array of char pointers, and fed into it 2 string literals. I'm then assuming that the original array becomes 2 dimensional; with each element containing each literal, and down a level so to speak each character of said literal.

Assuming that this above assumption is right, how do I go about manipulating said array. I've toyed about with the code and just managed to extract the "Hello'.
Also, all the examples I've seen seem to require a size be stated before hand to manipulate it. Is this the only way I can do it?

[Neo1]

This is not C++ code, this is C. There is not a single good reason to use a char[] instead of a std::string.
This leads me to your next question: Yes, you can find the length of a std::string by calling the member function length() or size(), as for C style arrays you have to iterate through the string until you reach NULL (as C uses NULL-terminated arrays), alternatively, there is a function in the C standard library that you can use, but really, you should just steer clear of all that and use std::string.
For a 2 dimensional string you could use a std::vector containing two strings, thus you could avoid using raw pointers altogether.

[GReaper]

This is not C++ code, this is C.

OMG! Does C really support OOP?! ( cout for example )

There is not a single good reason to use a char[] instead of a std::string.

There IS one ... don't know how to use the STL like std::string or std::vector

@TastySauceCode, the C++ way is to use a vector and a string class like this:

// Additional includes
#include <vector>
#include <string>

// Vector of Strings declaration
std::vector<std::string> strVec;

// Filling the vector
strVec.push_back(std::string("Word1"));
strVec.push_back(std::string("Word2"));
... etc ... etc ...

// Either ::iterator or ::const_iterator
std::vector<std::string>::iterator i; 

// Iterating and printing all vector strings
for (i = strVec.begin(); i < strVec.end(); i++){
    std::cout << *i << endl;
}

// Virtually all STL classes free themselves upon hitting the end of their scope

STL Tutorial : Cprogramming.com

EDIT: Thank God ( admin ), we finally have syntax highlighting! That's it, I can die now!

[TastySauceCode]

Thanks for taking the time to show me the proper C++ way of doing this :-) The real purpose originally though was just to try and get to grips with the logic behind it; I like reading other people's code examples and then attempting to break down the bits I don't quite understand. And I guess in this case the person in question has reverted to some C based stuff.

Am I right in assuming that the array has gone 2 dimensional? and probably because string literals are themselves null terminated char arrays I'm guessing.

[manasij7479]

Am I right in assuming that the array has gone 2 dimensional? and probably because string literals are themselves null terminated char arrays I'm guessing.

Think in terms of objects instead of(or in addition to) arrays.

This is a vector(which you can consider a 1d dynamic array of a specified type) of string objects, not a 2d array.

[Elkvis]

C++ now supports uniform initialization, including initialization lists, so to extend your example:

// Additional includes
#include <vector>
#include <string>
 
// Vector of Strings declaration
std::vector<std::string> strVec;

// declaration and initialization in one shot
std::vector<std::string> newVec = { "Hello", "world" };
 
// Filling the vector
strVec.push_back(std::string("Word1"));
strVec.push_back(std::string("Word2"));
... etc ... etc ...
 
// Either ::iterator or ::const_iterator
std::vector<std::string>::iterator i; 
 
// Iterating and printing all vector strings
for (i = strVec.begin(); i < strVec.end(); i++){
    std::cout << *i << endl;

// iterate over the 'newVec' the new way
for (std::string& s : newVec)
    std::cout << s << std::endl;

}

[TastySauceCode]

Think in terms of objects instead of(or in addition to) arrays.

This is a vector(which you can consider a 1d dynamic array of a specified type) of string objects, not a 2d array.

Ah sorry about that, I meant in the original code example. Not the uber efficient C++ variant kindly posted :-)

[Elysia]

I am just going to try and provide an example for compilers that does not support initializer lists (eg, Visual C++):

// Additional includes
#include <vector>
#include <string>
 
// declaration and initialization in one shot
const char* tmp[] = { "Hello", "world" };

// Vector of Strings declaration
std::vector<std::string> strVec(tmp, tmp + sizeof(tmp) / sizeof(tmp[0]));
 
// Either ::iterator or ::const_iterator
std::vector<std::string>::iterator i; 
 
// Iterating and printing all vector strings
for (i = strVec.begin(); i < strVec.end(); i++)
    std::cout << *i << endl;
}

[Neo1]

Am I right in assuming that the array has gone 2 dimensional? and probably because string literals are themselves null terminated char arrays I'm guessing.

nu_array is essentially a pointer to a pointer to a char. Instead of writing char *nu_array[] you could do char **nu_array and get essentially the same effect (or char nu_array[][], although i believe you have to specify the size of the second dimension, i'm not sure, has been a while since i used raw pointers like this). In other words nu_array is a pointer to an array of chars.
I suggest you read up on pointers, grasping what they are and how they work is a good exercise, although there are few valid usages for them in modern C++.

[GReaper]

// iterate over the 'newVec' the new way
for (std::string& s : newVec)
    std::cout << s << std::endl;
}

I hesitate to use the "new way". We should wait for C++11 to become standard first...

[Elysia]

It is standard. But I take it that you mean widely supported by compilers. Currently there is only one popular compiler that support this feature (GCC).

[GReaper]

But I take it that you mean widely supported by compilers.

Yes, that's what I meant.