Zablokowane Klasa ze wskaźnikami - przeciążanie operatorów

[Rudy]

Witam.

 

Mam pewien problem, otóż chcę zrobić klasę (coś w rodzaju tablicy) z własnymi operatorami. Kod wygląda mniej więcej tak:

 

#include <cstdio>

using namespace std;
typedef unsigned char BYTE;
typedef unsigned int DWORD;

template <typename T1, typename T2> inline T1 min(T1 v1, T2 v2) { return (v1 > v2) ? v2 : v1; }
template <typename T1, typename T2> inline T1 max(T1 v1, T2 v2) { return (v1 < v2) ? v2 : v1; }

class Array
{
  private:
    DWORD* dwValue;
    const DWORD dwCount;

  public:
    Array(DWORD dwNumber = 1) : dwCount(dwNumber)
      { dwValue = new DWORD[dwCount]; }
    Array(Array& aRight) : dwCount(aRight.GetCount()) // edycja
    {
      dwValue = new DWORD[dwCount];
      for (DWORD dwIndex = 0; dwIndex < dwCount; ++dwIndex)
      dwValue[dwIndex] = aRight[dwIndex];
    }
    ~Array()
      { delete[] dwValue; }

    DWORD GetCount() const
      { return dwCount; }

    DWORD& operator[](DWORD dwIndex)
      { return dwValue[dwIndex]; }

    Array& operator=(Array& aRight)
    {
      if (this != &aRight)
      {
        DWORD dwCopy = min(dwCount, aRight.GetCount());
        for (DWORD dwIndex = 0; dwIndex < dwCopy; ++dwIndex)
          dwValue[dwIndex] = aRight[dwIndex];
      }
      return *this;
    }
};

Array operator+(Array& aLeft, Array& aRight)
{
  Array aRet;
  DWORD dwAdd = min(aLeft.GetCount(), aRight.GetCount());
  for (DWORD dwIndex = 0; dwIndex < dwAdd; ++dwIndex)
    aRet[dwIndex] = aLeft[dwIndex]+aRight[dwIndex];
  return aRet;
}


int main()
{
  Array value1(1);
  Array value2(1);
  value1[0] = 8;
  value2[0] = 25;

  value1 = value2;
  value1 = value1+value2;
  return 0;
}

 

Kompilator wypisuje coś takiego:

In function `int main()':
error: no match for 'operator=' in 'value1 = operator+(Array&, Array&)(((Array&)(&value2)))'
note: candidates are: Array& Array::operator=(Array&)
=== Build finished: 1 errors, 0 warnings ===

 

Problem, jak zakładam będzie w miejscach występowania referencji (gdzieś powinna/nie powinna być). Przy okazji chciałbym się spytać, czy wymagany jest tu konstruktor kopiujący i jaka powinien być jego prototyp. Wszelkie dodatkowe rady również mile widziane :)

[Will]

Na oko tego błędu nie powinno być, jaki kompilator? Program i tak po poprawnej kompilacji wysypie się w tym samym miejscu jako, że temporary obiekt zostanie zniszczony a defaultowy konstruktor kopiujący przekaże ten sam adres. Po prostu wrzuć kopiowanie pamięci ze sterty do nowego bufora w własnym konstruktorze kopiującym.

[Rudy]

Kompilator: GCC (MinGW) w Code::Blocks (we Visualu nie wykrył błędu, ale wysypał się)

 

Dodałem coś takiego:

 

Array(Array& aRight) : dwCount(aRight.GetCount())
{
  dwValue = new DWORD[dwCount];
  for (DWORD dwIndex = 0; dwIndex < dwCount; ++dwIndex)
    dwValue[dwIndex] = aRight[dwIndex];
}

Myślę, że dobrze, błąd jednak się powtarza.

[Will]

U mnie śmiga na visual'u. Zamień "Array& operator=(Array& aRight)" na "Array& operator=(Array aRight)" i napisz czy to samo.

[Rudy]

Faktycznie, Visual odpala (bez zmiany konstruktora kopiującego, ale jednak go wymaga), C::B wciąż ma problemy. Będę kontynuował na Visualu, trzeba tylko jeszcze rozwiązać problem przekazania lokalnego wyniku dodawania. Jak to można zrobić?

[Will]

trzeba tylko jeszcze rozwiązać problem przekazania lokalnego wyniku dodawania. Jak to można zrobić?

Ten konstruktor kopiujący?

[Rudy]

Nie rozwiązuje problemu. Dane klasy - wyniku tracą się wraz z wyjściem z funkcji dodawania.

[Will]

U mnie działa, końcowy wynik 50.

#include <cstdio>

using namespace std;
typedef unsigned char BYTE;
typedef unsigned int DWORD;

template <typename T1, typename T2> inline T1 min(T1 v1, T2 v2) { return (v1 > v2) ? v2 : v1; }
template <typename T1, typename T2> inline T1 max(T1 v1, T2 v2) { return (v1 < v2) ? v2 : v1; }

class Array
{
private:
    DWORD* dwValue;
    const DWORD dwCount;

public:
    Array(DWORD dwNumber = 1) : dwCount(dwNumber)
    { dwValue = new DWORD[dwCount]; }
    ~Array()
    { delete[] dwValue; }

    DWORD GetCount() const
    { return dwCount; }

    DWORD& operator[](DWORD dwIndex)
    { return dwValue[dwIndex]; }

    Array& operator=(Array aRight)
    {
        if (this != &aRight)
        {
            DWORD dwCopy = min(dwCount, aRight.GetCount());
            for (DWORD dwIndex = 0; dwIndex <= dwCopy; ++dwIndex)
                dwValue[dwIndex] = aRight[dwIndex];
        }
        return *this;
    }

    Array(Array& aRight) : dwCount(aRight.GetCount())
    {
        dwValue = new DWORD[dwCount];
        for (DWORD dwIndex = 0; dwIndex < dwCount; ++dwIndex)
            dwValue[dwIndex] = aRight[dwIndex];
    }
};

Array operator+(Array& aLeft, Array& aRight)
{
    Array aRet;
    DWORD dwAdd = min(aLeft.GetCount(), aRight.GetCount());
    for (DWORD dwIndex = 0; dwIndex < dwAdd; ++dwIndex)
        aRet[dwIndex] = aLeft[dwIndex]+aRight[dwIndex];
    return aRet;
}


int main()
{
    Array value1(1);
    Array value2(1);
    value1[0] = 8;
    value2[0] = 25;

    value1 = value2;
    value1 = value1+value2;
    return 0;
}

[Rudy]

Ok, mój błąd :D . Żeby nie ujawniać szczegółów projektu wpisałem tutaj kod, który powoduje ten sam problem, lecz to nie ten sam kod, co u mnie. W konstruktorze kopiującym dałem po prostu zły znak w pętli kopiowania ;) .

 

Dzięki za pomoc, temat uważam za zamknięty ;) .