студенческие вопросы

[pinkiller]

есть динамический массив, который рискует переполниться.
чтобы избежать этого использую незамысловатую операцию:
"if ((u-d)<c)
{
z=z*2
int *te2 = new int[z];
for (int p; p<=z;p++) {
te2[p]=te[p];
}
delete te;
te=te2;
)"
проблема в том что в основном тексте програамы этот массив te[] называеться term[] а операция выше находиться внутри функции... вопрос как сделать так чтобы term поменял свой адрес в мейне, а не только внутри этой функции....

[Smitt&Wesson]

Сделайте массив term[] глобальным. Тогда любая функция сможет менять его размер.

[Abstraction]

Сообщение от Smitt&Wesson

Сделайте массив term[] глобальным. Тогда любая функция сможет менять его размер.

"Вредные советы" от Smitt&Wesson.

В C++ (да и в других языках) при передаче параметра в функцию без дополнительных уточнений, он передаётся "по значению" - то есть, для функции создаётся персональная копия объекта, с которой она может делать всё, что угодно. В случае массива, "объект массива" int* (int[]) - это переменная содержащая адрес начала массива - поэтому

void ChangeContent(int* array){
  array[3]=0;
}

void CallFunction(void){
  int* original = new int[20];
  original[3]=1;
  ChangeContent(original);
  //Здесь original[3] равно 0
  delete[] original;
}

Кстати, обращаю внимание, что, если адрес памяти, записанной в указатель, был получен с помощью формы new[] оператора new, освобождать её надо с помощью delete[].

А как поменять сам original? Для этого нужно передать в функцию не значение переменной, а её адрес. В C++ есть два способа для этого. Первый выглядит очень просто:

void ChangeArray(int*& array){
  int* newArray = new int[40];
  newArray[3]=array[3];
  delete[] array;
  array=newArray;
}

void CallFunction(void){
  int* original = new int[20];
  original[3]=1;
  ChangeArray(original);
  //original изменился, и теперь можно сделать так:
  original[33]=2;
  delete[] original;
}

В конец типа аргумента функции приписывается & - и аргумент будет передаваться в функцию по ссылке, а не по значению; синтаксис работы с ним при этом совершенно не изменится. Это удобно, но это опасно: попробуйте при чтении кода понять, меняет ли DoSomethingWithArray(original) свой аргумент?
Но есть второй способ, подчёркивающий, что аргумент передаётся по ссылке и может меняться внутри функции.

//Функция принимает указатель на указатель на int
void ChangeArray(int** array){
  int* newArray = new int[40];
  //Унарная * - оператор разыменования указателя, "вытащить то, адрес чего хранится в переменной"
  newArray[3]=(*array)[3];
  delete[] (*array);
  *array=newArray;
}

void CallFunction(void){
  int* original = new int[20];
  original[3]=1;
  //В явном виде передаём в функцию адрес original
  ChangeArray(&original);
  //original изменился, и теперь можно сделать так:
  original[33]=2;
  delete[] original;
}

Первый способ обычно используется с другой целью: если в функцию нужно передать здоровый объект, копирование которого является долгой операцией.

[Smitt&Wesson]

"Вредные советы" от Smitt&Wesson.

Согласен. Вредный. Но если прога небольшая, ничего в этом страшного нет. А написание кода упрощается в разы.

[pinkiller]

как же блин все сложно и непонятно((

[An1ka]

Что сложного ? Поставить одну закорючку амперсанд в аргументе функции ? =)

[pinkiller]

Охохохо) Разыменование) вообще я не понял где вот тут:

//Функция принимает указатель на указатель на int
void ChangeArray(int** array){
  int* newArray = new int[40];
  //Унарная * - оператор разыменования указателя, "вытащить то, адрес чего хранится в переменной"
  newArray[3]=(*array)[3];
  delete[] (*array);
  *array=newArray;
}

void CallFunction(void){
  int* original = new int[20];
  original[3]=1;
  //В явном виде передаём в функцию адрес original
  ChangeArray(&original);
  //original изменился, и теперь можно сделать так:
  original[33]=2;
  delete[] original;
}

увеличение размера. то ради чего все затевалось(

[Abstraction]

До вызова ChangeArray размер массива original был 20. После вызова стал 40, что проиллюстрировано обращением к 34-му элементу.

[pinkiller]

//Функция принимает указатель на указатель на int

int z; // глобальный параметр
void ChangeArray(int** array){
  int* newArray = new int[z*2];
  //Унарная * - оператор разыменования указателя, "вытащить то, адрес чего хранится в переменной"
  newArray[3]=(*array)[3];
  delete[] (*array);
  *array=newArray;
}

void CallFunction(void){
  z=20;
  int* original = new int[z];
  original[3]=1;
  //В явном виде передаём в функцию адрес original
  ChangeArray(&original);
  //original изменился, и теперь можно сделать так:
  original[33]=2;
  delete[] original;
}

так можно сделать?

[Abstraction]

Можно. Только нужно изменить само z, а то повторный вызов ChangeArray оставит размер 40, вместо удвоения.
Хотя правильней таскать z вместе с массивом, с глобальными параметрами риск что-нибудь напутать слишком быстро растёт при увеличении объёмов кода
(и стоит в программе появиться двум-трём расширяемым массивам, как головная боль при "глобальном" подходе гарантирована). Т.е. в простейшем случае нужно добавить в ChangeArray второй параметр, указатель на длину массива. Там его и менять.
Ещё более правильный способ - образовать структуру из массива и его длины и передавать его единым объектом. Но если Вы пока не разбирались со структурами, пока сойдёт и так.