Pæn måde at arbejde med koordinater

Jeg ville jo nok lave en move metode med to argumenter: difx og dify

#include <iostream>

class PointClass
{
public:
  PointClass(int aX, int aY) : X(aX), Y(aY)
  {}
  bool operator == (const PointClass &rhs)
  {
      return X == rhs.X && Y == rhs.Y;
  }
  bool operator != (const PointClass &rhs)
  {
      return !(operator == (rhs));
  }
  class CoorClass
  {
  public:
      CoorClass(int aC) : C(aC)
      {
      }
      CoorClass & operator ++()
      {
        C++;
        return *this;
      }
      CoorClass & operator --()
      {
        C--;
        return *this;
      }
      bool operator == (const CoorClass &rhs)
      {
        return C == rhs.C;
      }
      int C;
  };
  CoorClass X;
  CoorClass Y;
};



int main()
{
  PointClass P1(10, 10), P2(10, 11), P3(10, 10);
  if(P1 == P3)
      std::cout << "P1 and P3 is at same spot" << std::endl;
  if(P1 != P2)
      std::cout << "P1 and P2 is not at same spot" << std::endl;
  --P2.Y;
  if(P1 == P2)
      std::cout << "P1 and P2 is at same spot" << std::endl;

}

bertelbrander >> Mange tak for eksemplet, må indrømme jeg ikke helt har tænkt i den retning. Har bare lige et spørgsmål.
  Bruger man ofte det at have en klasse inden i en anden?

mener deffinere den inden i en anden, lød lidt forkert

Ofte og ofte...

Hvis en class kun skal bruges af en anden class er det en god idé at gøre det.
Det er ikke noget jeg bruger ofte, men det forekommer.

ok
  arne_v >> gider du ikke svare?
  bertelbrander >< Mangfe tak for eksemplet, det bliver en stor hjælp

jeg kan vist ikke fortjene point her ...

Du har da taget dig tid til at læse mit spørgsmål og komme med en kommentar. Men vil da ikke tvinge dig til at tage imod point :)

Tænkte lige på, hvis jeg ændrer koden til følgende:

#include <iostream>

class PointClass
{
public:
  PointClass(int aX, int aY) : X(aX), Y(aY)
  {}
  bool operator == (const PointClass &rhs)
  {
    return X == rhs.X && Y == rhs.Y;
  }
  bool operator != (const PointClass &rhs)
  {
    return !(operator == (rhs));
  }

  int X;
  int Y;
}



int main()
{
  PointClass P1(10, 10), P2(10, 11), P3(10, 10);
  if(P1 == P3)
    std::cout << "P1 and P3 is at same spot" << std::endl;
  if(P1 != P2)
    std::cout << "P1 and P2 is not at same spot" << std::endl;
  --P2.Y;
  if(P1 == P2)
    std::cout << "P1 and P2 is at same spot" << std::endl;
}

  SÅ virker det stadig. Hvad er fordelen ved CoorClass så?

encapsulation

I dette simple eksempel er der ikke den store fordel ved at bruge CoorClass frem for en almindelig int, men,

Hvis PointClass bruges til at repræsentere en mand i et shoot-em-up spil, kunne man bruge ++ og -- operatoren i CoorClass til at flytte manden på skærmen.

Igen mange tak for jeres svar. Jeg har fået det til at virke efter planen så det kunne ikke være meget bedre