Оператор перегрузки ‘+’ для добавления двух массивов в переполнение стека
Я хочу добавить два массива, просто написав:
int a[4] = {1,2,3,4};
int b[4] = {2,1,3,1};
int sum[4] = a + b;
Я написал эту функцию, но я получил ошибку
int* operator+(const uint32& other) const{
uint32 sum[n];
for(int i=0; i<n; i++){
sum[i] = (*this[i]) + other[i];
}
return sum;
}
Не могли бы вы помочь мне в этом? Заранее спасибо.
Решение
Это, вероятно, неправильно, но, похоже, работает (C ++ 11):
#include <iostream>
#include <array>
using namespace std;
template <class T>
T operator+(const T& a1, const T& a2)
{
T a;
for (typename T::size_type i = 0; i < a1.size(); i++)
a[i] = a1[i] + a2[i];
return a;
}
int main()
{
array<int,5> a1 = { 1, 2, 3, 4, 5 };
array<int,5> a2 = { 2, 3, 4, 5, 6 };
array<int,5> a3 = a1 + a2;
for (int i = 0; i < 5; i++)
cout << a1[i] << '+' << a2[i] << '=' << a3[i] << ' ';
cout << endl;
return 0;
}
Выход (ideone):
1+2=3 2+3=5 3+4=7 4+5=9 5+6=11
Другие решения
Давайте рассмотрим ваш код по частям и посмотрим на проблемы:
int* operator+(const uint32& other) const{
- Вы не можете перегружать операторы для встроенных типов, так что это обречено с самого начала
- Даже если вы могли бы сделать это (что вы не можете), он должен принять два параметра, поскольку он не является бинарной функцией.
uint32 sum[n];
- Вы не можете создавать массивы переменной длины в C ++ (при условии
nне является константой времени компиляции) (примечание: в G ++ есть некоторые расширения, которые позволяют это, но это нестандартный C ++)
for(int i=0; i<n; i++){ sum[i] = (*this[i]) + other[i];
- Нет никаких
thisуказатель для начала в этом коде (это не функция-член) … const uint32& otherявляется не массив / указатель на массив. Это одна ссылка на одинuint32, Это означает, чтоotherв этом коде не массив / указатель на массив, и поэтому вы не можете сделатьother[i](это как пытаться сделатьint x = 3; x[4] = 13;, что не имеет смысла).
} return sum;
- Вы возвращаете указатель на локально распределенный массив, что означает, что это приведет к неопределенному поведению, так как память связана с
sumбудет уничтожен, когда эта функция вернется.
}
Я думаю, что проблема в том, что вам не хватает способа передать длину массива. Возможно, вам придется сделать что-то более сложное. Что-то вроде:
class AddingVector : public std::vector<int>
{
public:
typedef AddingVector type;
type operator+(const AddingVector& rhs, const AddingVector& lhs)
{
/* validate that they're the same size, decide how you want to handle that*/
AddingVector retVal;
AddingVector::const_iterator rIter = rhs.begin();
AddingVector::const_iterator lIter = lhs.begin();
while (rIter != rhs.end() && lIter != lhs.end()) {
retVal.push_back(*rIter + *lIter);
++rIter;
++lIter;
}
return retVal;
}
}
Тебе этого не сделать. Бинарные операторы, не являющиеся членами, должны принимать два аргумента (вы предоставили только один), поэтому вы можете попробовать это:
int* operator+(const uint32& a, const uint32& b)
Но это также не может работать, так как вы хотите добавить массивы, а не один uint32 переменные. Таким образом, вы думаете, что это сделает это:
int* operator+(const uint32[] a, const uint32[] b)
или же:
int* operator+(const uint32[4] a, const uint32[4] b)
Но не идти. Это недопустимо, потому что вы не можете иметь типы указателей в качестве обоих аргументов при перегрузке оператора. Кроме того, по крайней мере один из аргументов должен быть типом класса или enum, То, что вы пытаетесь сделать, уже невозможно по крайней мере на двух разных уровнях.
Невозможно делать то, что ты хочешь. Один правильный способ сделать это — написать собственный класс для массива, который можно добавить в другой.
Вы не можете перегружать операторы для типов, отличных от ваших собственных определенных типов. То есть, если вы создаете класс X, вы можете перегружать операторы для X, но вы не можете перегружать операторы для массивов или указателей на фундаментальные типы.
во-первых, ваш код компилируется правильно, вы использовали ‘n’ непосредственно в объявлении массива, ‘n’ объявлено как константа ..
И, кроме того, вы взяли локальную переменную в функции и вернули ее, ну, это возвращает мусор из стека, что я могу предложить, если вы используете malloc некоторую память и используете ее, но, опять же, ее освобождение будет необходимо …
Эй, что вы могли бы сделать,
Возьми обёртку класса «массив»
class array
{
int *ipArr;
DWORD size;
};
тогда в конструкторе вы можете передать размер, который вы хотите иметь массив
array(DWORD dwSize);
{
// then malloc memory of size dwSize;
}
У этого класса есть перегруженный оператор ‘+’, в котором будет реализована реализация добавления двух массивов int:
Обратите внимание, что здесь вам также понадобится перекрыть оператор присваивания ‘=’, чтобы наш класс массива мог напрямую.
теперь вы можете освободить связанную память в деструкторе
У вас есть несколько проблем. Во-первых, вы не передаете оба массива, а затем вы не указываете, что такое n, и последнее, что вы пытаетесь передать указатель на локальную переменную. Похоже, вы пытаетесь сделать оператор-член класса.
Поэтому в основном вы пытаетесь добавить содержимое массива неопределенной длины в неинициализированный массив той же длины и вернуть память стека.
Так что, если вы передадите указатели на массивы, длину массива и выходной массив, то это будет работать, но у вас не будет синтаксиса
sum = a + b;
это было бы что-то вроде
addArray(&a, &b, &sum, 4);
Чтобы получить синтаксис, который вы хотите, вы можете создать класс, который оборачивает массив. Но это гораздо более сложная задача.
detector