create global dynamic array inside the function

I am writing a programm in C++. In my programm I need to create an array with dynamic size inside one function, but this array should be also accessable for other functions. I will not post here my code, just write one dummy example.

char *array;


void function_1() {
    array = new char(3);
    array[0] = "value 1";
    array[1] = "value 2";
    array[2] = "value开发者_JAVA技巧 3";
}

void function_2() {
    array[0] = "new value 1";
}

int main() {
    function_1();
    function_2();

    delete[] array;
}

My question is: I am not sure, if the array will exist outside the function_1, where it was initialised, until I delocate a memory of array. Or the array will have just a behaviour of local variable inside one function. What means, that the memory, which stores the array values, will be dellocated after the function is finished and the memory addresses of my array can be rewroten with something else later in my programm.

Thank you.

---

First, of course it will exist outside, that's all what dynamic allocation is about. Also, the variable itself is global. Also, it should be a char const** array; and the allocation should be new char const*[3] (note the square brackets). The const because you won't change the contents of the strings here.

Second, don't do that. Just put it in a class and use a std::vector!

#include <vector>

class Foo{
public:
  function_1(){
    _array.push_back("value 1");
    _array.push_back("value 2");
    _array.push_back("value 3");
  }

  function_2(){
    _array[0] = ("new value 1");
  }

private:
  std::vector<std::string> _array;
};

int main(){
  Foo f;
  f.function_1();
  f.function_2();
}

Even better, have a std::vector<std::string>, so you can safely modify the contents without having to worry about memory management. Though, to this won't be a single block any more. Now I got to ask, how exactly do you want to pass the buffer to the socket?

---

You actually have a fatal error in your function_1(). The following code will cause array to point to a character, with the value 3. Then, it will overwrite various parts of neighboring memory, basically causing a buffer overflow.

void function_1() {
    array = new char(3);
    array[0] = "value 1";
    array[1] = "value 2";
    array[2] = "value 3";
}

What you probably want to do is create something like:

char **array;
array = new char*[3];
array[0] = new char[strlen(...)];
array[0] = strncpy(array[0], ..., strlen(...)];
// etc

A much safer and cleaner way of accomplishing this would be to do what Xeo is suggesting, and using a std::vector instead of a plain array.

---

Since array is global, it is visible to other functions. Memory allocated with new[] stays around until it is freed by delete[].

---

It will exist and be global, because the char * array pointer is global.

---

The memory that you allocate in function1 will stay allocated after the program exits the scope of the function and will work as expected in functions 2 and 3. Notice however, that behaviour is undefined if you call functions 2 and 3 before function one. In general though, what you're trying to do here looks like bad design, but for the sake of the question I won't bug you about that now :)

---

It would greatly improve the clarity of your code if you'd:

• use a std::vector, especially if you plan to resize it later
• use a std::string to represent strings

• pass the array or vector by reference to the functions that need it.

  int main() {
  std::vector<std::string> vect;
  
  function_1(vect);
  function_2(vect);
  }
  

where your functions look like:

void function_1(std::vector<std::string> & Vect) 

typedefs help manage the argument types

This way you won't have to worry about leaks as the vector will deallocate itself when out of scope.