Возвращаемый массив в C ++

Question

Я нуб всего C ++, и у меня возникают проблемы с возвратом массива из моих методов. У меня есть файл заголовка со следующим объявлением метода:

virtual double[]
echoDoubleArray(double[] doubleArray, int arraySize) throw (RemoteException);

Это дает мне следующую ошибку:

../common/EchoService.h: At global scope:
../common/EchoService.h:25: error: expected unqualified-id before ‘[’ token

Как правильно вернуть массив?

Answer 1

C ++ плохо работает с нелокальными массивами, более вероятно, что вы должны использовать реальный контейнер, такой как std::array<double,10> или std::vector<double>.Я не думаю, что можно вернуть массив из функции.

Answer 2

Вам лучше использовать std :: vector или, если вы действительно хотите вернуть простой массив, вернуть указатель (на такой массив), динамически выделенный, например,

double* arr = new double[arrSize];
// fill arr appropriately
return arr;

Но я рекомендую вернуть std::vector<double>.

Answer 3

Существует методика передачи массивов, которые не распадаются на указатели. Вы передаете массив по ссылке, используя синтаксис ниже. Требуемые «дополнительные» парены являются синтаксической бородавкой, и, вероятно, почему это использование не является более распространенным. Привыкаешь к этому очень быстро, учитывая преимущества.

void sub(double (&foo)[4])
{
    cout << sizeof(foo) << endl;
}

Печатает 32, а не sizeof (double *), потому что тип foo действительно равен ссылкой на массив из 4 double. Используя шаблоны, вы можете обобщить работу для любого размера массива:

template <int N> sub(double (&foo)[N])
 {
    cout << sizeof(foo) << endl;
 }

 double bar[5];
 double zot[3];
 sub(bar); // ==> 40
 sub(zot); // ==> 24

Вы можете снова обобщить, чтобы обработать массив любого размера:

template <class T, int N>void sub(T(&foo)[N])
    {
        cout << sizeof(foo) << endl;
    }

double bar[5];
char zot[3];
sub(bar); // ==> 40
sub(zot); // ==> 3

и теперь у вас есть нечто, что отражает абстрактную идею «sub» независимо от типа или размера массива, который вы передаете.

Answer 4

Извините, все, кажется, говорят вам использовать современное программирование типа STL вместо ответа на ваш вопрос. Они правы . Но вы все равно должны понимать, как все работает. Проблема с возвратом массивов состоит в том, что массивы, созданные в вашей функции, будут в стеке. Когда вы покидаете свою функцию, их больше не будет. Что вы можете сделать, это вернуть указатель на массив в куче. Исследуйте немного больше о стеке и куче, чтобы понять. Но ниже приведена простая функция C ++, возвращающая массив, выделенный в куче.

#include <iostream>

double * MakeArray()
{
   double *mydouble = new double[5]; 
   mydouble[1]=1.1;
   mydouble[1]=2.2;
  return mydouble;
}

int main()
{

  double *d=MakeArray();
  std::cout<<d[1]<<d[2];
  delete[] d; 
}

редактирование:

Подумав об этом еще, другим способом сделать это без STL будет возвращение структуры с массивом в нем. Большинство компиляторов возвращают структуру по значению (при условии, что вы не занимаетесь встроенным программированием).

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

#include <iostream>

void MakeArray(double d[5])
{
  d[0] = 0.0; d[1] = 1.1;
  d[2] = 2.2; d[3] = 3.3; d[4] =4.4;
}

int main()
{
  double dub[5];
  MakeArray(dub);
  std::cout<<dub[1]<<dub[2];
}

После понимания, как все работает. иди используй STL.

Answer 5

Чтобы ответить на ваш вопрос более прямо, если вы объявите массив значений типа double следующим образом:

double doubleArray[] = {1.0, 2.0, 3.0};

, вы объявите метод следующим образом:

virtual double *
echoDoubleArray(double* doubleArray, int arraySize) throw (RemoteException);

Массивы передаются какуказатели.Если вы хотите использовать истинную силу C ++, следуйте советам, приведенным в других ответах.

Answer 6

Синтаксис C ++ для массивов: std::vector<double> вместо double[]. Также требуется, чтобы вы поместили #include <vector> в верхней части исходного файла. Кроме того, они работают очень похоже на C-массивы.