Thread: Arrays of pointers...

Originally Posted by Programmer_P

No, actually I just ignored that part, and added an initializer list to initialize the array of pointers to NULL like you have in your posted code a few posts back... So I still followed your advice, just not the statement about no member pointers.

Do you think that it would output the strings, and not the memory addresses, if I did that though? If not, I wont bother changing it since its just a test program anyway.

If you're hell bent on using pointers when there is no need, then why is 'object' not declared as a pointer to stringStruct?

Code:

stringStruct *object;
object->str = new string;
*object->str = "Yes, a string...\n";
// etc
delete object;

Oh and how about sizeOfArrayOfPointer:

Code:

int *sizeOfArrayOfPointer;
sizeOfArrayOfPointer = new int;
*sizeOfArrayOfPointers = 0;
// etc
delete sizeOfArrayOfPointers;

I mean, you can see why this is redundant and silly right? So how is it that you think declaring pointers to those strings isn't just as redundant?

I'm going to make assumptions about what your code is meant to be doing and just show you an improvement. I assume you are trying to split the string at the newlines and print out each string from the array of pointers. The following is better, and should achieve your goal. This code is still not ideal, but this is probably not a sensible thing to be doing in the first place.

Code:

#include <iostream>
#include <string>

using namespace std;

struct stringStruct {
  stringStruct() : arrayOfPointers(NULL) {}
  string str;
  const char** arrayOfPointers; // Should really be a vector
  ~stringStruct() { delete [] object.arrayOfPointers; } // Safer to do this here
private: // Standard code for preventing an object from being copied, follows
  stringStruct(const stringStruct&);
  stringStruct& operator=(const stringStruct&);
};

void doStuff();

int main(void) {
  doStuff();
  cin.get();
  return 0;
}

void doStuff() {
  stringStruct object;
  object.str = "Yes, a string...\n"
     "Yes, another string...\n"
     "Yes, even another string...\n"; // You can concatenate string literals more efficiently like this
  int sizeOfStr = object.str.size();
  int numberOfPointers = 0;
  for (int i = 0; i < sizeOfStr; i++) {
     if (object.str.at(i) != '\n') {
        numberOfPointers++;
     } else {
        object.str[i] = '\0'; // We cant output the string later if it isn't null-terminated
        // Also we have to make all modifications prior to calling data(), so it's done here
     }
  }
  object.arrayOfPointers = new const char*[numberOfPointers];
  int i2 = 0;
  for (int i = 0; i < numberOfPointers; i++) {
     object.arrayOfPointers[i] = &object.str.data()[i2];
     while (object.str.at(i2) != '\0)
        i2++;
     i2++;
  }
  for (int i = 0; i < numberOfPointers; i++) {
     cout<< object.arrayOfPointers[i] << endl;
  }
}

Your code had several major flaws that meant it could never work as it was, hence the significant changes. E.g. you couldn't cout the pointers obtained from the string's data() because they weren't guaranteed to be null-terminated. There is no place for 'sizeof' in that program.

What is your current code? Why are you not using a std::vector or other appropriate container?

Originally Posted by iMalc

If you're hell bent on using pointers when there is no need, then why is 'object' not declared as a pointer to stringStruct?

Code:

stringStruct *object;
object->str = new string;
*object->str = "Yes, a string...\n";
// etc
delete object;

Oh and how about sizeOfArrayOfPointer:

Code:

int *sizeOfArrayOfPointer;
sizeOfArrayOfPointer = new int;
*sizeOfArrayOfPointers = 0;
// etc
delete sizeOfArrayOfPointers;

I mean, you can see why this is redundant and silly right? So how is it that you think declaring pointers to those strings isn't just as redundant?

Because the point of using an array of pointers to those strings is so I can later return a pointer to the whole array, and be able to easily access each string I want to access (separately), in my real program. If I try using just a normal char array[], for example, then I can only store one continuous string. I could of course separate individual strings inside the normal char array with a character like '\n', but I don't want to do that. I want to have the ability to access each individual string of the array, by simply accessing a specific array index. See, what this real program does is it reads from a file line by line, storing the contents of the line in a char array called "filestreamInBuffer". I then check the contents of that array to see if it contains the string which I'm searching for (i.e. "enum"). If it does, I continue reading lines from that point until the terminating semicolon has been found (or if, for some bizarre reason, it doesn't, and it reaches the end of the file without finding it, I set a bool variable called "terminatingSemicolonDoesNotExist" as true, then break out of the loop). Now, here is where the fun begins...
Before I find the terminating semicolon, I add each line of the file after the line of which "enum" was found to a string (after first stripping it to contain only the string name of the enum value). I also count how many enum values have been found, so that once all that is done, I can create a new char* array with the size of the number of enum values. I then do something similiar to what I did in the test program, i.e. loop through that string which contains all the enum values, and adding characters to another string so long as the current character is not a new-line character, and then assigning the resulting string to the current index element of the char* array. Once that function has done all the stuff I wrote it to do, I can then retrieve all the bits and pieces of the enum separately (i.e. like the enum name, the names of the enum values as a char* array), and everything's just dandy. The whole point of the real program is so I can easily retrieve the string names of the enum values of any enum.
Of course, though, it would be nice to get the whole logic of the array of pointers working first...

I'm going to make assumptions about what your code is meant to be doing and just show you an improvement. I assume you are trying to split the string at the newlines and print out each string from the array of pointers. The following is better, and should achieve your goal. This code is still not ideal, but this is probably not a sensible thing to be doing in the first place.

You are correct with that assumption. Basically, I want to add individual strings to a string type, separating them with a '\n' character. I then want to loop through that string, and assign each string to the current element of the char* array up until the '\n' character is detected.

Code:

#include <iostream>
#include <string>

using namespace std;

struct stringStruct {
  stringStruct() : arrayOfPointers(NULL) {}
  string str;
  const char** arrayOfPointers; // Should really be a vector
  ~stringStruct() { delete [] object.arrayOfPointers; } // Safer to do this here
private: // Standard code for preventing an object from being copied, follows
  stringStruct(const stringStruct&);
  stringStruct& operator=(const stringStruct&);
};

Well, yes, obviously its best to delete a member variable from inside the class or struct destructor. I know this, but I didn't do it in this test program, because its so small, and I made sure to delete all "new" allocatations inside the "doStuff" function. And of course, I think you mean "delete [] arrayOfPointers;" not "delete [] object.arrayOfPointers" since we're inside the member function destructor, and "object" is a "stringStruct" object created inside the "doStuff" function.

Code:

void doStuff();

int main(void) {
  doStuff();
  cin.get();
  return 0;
}

void doStuff() {
  stringStruct object;
  object.str = "Yes, a string...\n"
     "Yes, another string...\n"
     "Yes, even another string...\n"; // You can concatenate string literals more efficiently like this
  int sizeOfStr = object.str.size();
  int numberOfPointers = 0;
  for (int i = 0; i < sizeOfStr; i++) {
     if (object.str.at(i) != '\n') {
        numberOfPointers++;
     } else {
        object.str[i] = '\0'; // We cant output the string later if it isn't null-terminated
        // Also we have to make all modifications prior to calling data(), so it's done here
     }
  }
  object.arrayOfPointers = new const char*[numberOfPointers];
  int i2 = 0;
  for (int i = 0; i < numberOfPointers; i++) {
     object.arrayOfPointers[i] = &object.str.data()[i2];
     while (object.str.at(i2) != '\0)
        i2++;
     i2++;
  }
  for (int i = 0; i < numberOfPointers; i++) {
     cout<< object.arrayOfPointers[i] << endl;
  }
}

Your code had several major flaws that meant it could never work as it was, hence the significant changes. E.g. you couldn't cout the pointers obtained from the string's data() because they weren't guaranteed to be null-terminated. There is no place for 'sizeof' in that program.

Well, I tried to fix that problem in my new version, however when I do this:

Code:

for (int i = 0; i < sizeOfStr; i++) {
    while (object.str->at(i2) != '\n') {
      *object.anotherStr += object.str->at(i2);
      i2++;
    }
    if (i == sizeOfArrayOfPointers - 2) {
        object.arrayOfPointers[i] = object.anotherStr->data();
        *object.arrayOfPointers[i+1] = '\0';
        break; //out of the loop since we're at the last element in the array of pointers
    }
    object.arrayOfPointers[i] = object.anotherStr->data();
    object.anotherStr = NULL; //reset this pointer
  }

It refuses to compile, because the bolded line is said to be trying to access a "read-only" location, which I guess means the array IS terminated with that character already after all...

EDIT: Nevermind...I see what you mean. Each character string (which means EVERY string pointed at by each element of the char* array) should be NULL-terminated. I'll get right on that right away..

Originally Posted by Programmer_P

Because the point of using an array of pointers to those strings is so I can later return a pointer to the whole array, and be able to easily access each string I want to access (separately), in my real program. If I try using just a normal char array[], for example, then I can only store one continuous string. I could of course separate individual strings inside the normal char array with a character like '\n', but I don't want to do that. I want to have the ability to access each individual string of the array, by simply accessing a specific array index.

I would reach for a std::vector<std::string>.

Originally Posted by Programmer_P

As to why I'm not using a vector, its because I don't need a resizable array. I only need a fixed-size array which is given a size based on how many individual strings are contained within one string (separated by a '\n' character)...

It still makes sense to use a vector since the size is not fixed at compile time. If you insist that it does not make sense, then rewrite your code to remove this:

Code:

new const char*[sizeOfArrayOfPointers]

because you don't need it. If you do need it, then you should use a std::vector or other appropriate container.