ZFX + Developia

Code: Alles auswählen

while (1)
{
      do
      {
        XNextEvent(Dply, &event);
        switch(event.type)
        {
          case KeyPress:
          {
            exit(0);
            break;
          }
          case ConfigureNotify:
          {
            glViewport
            (
              0,
              0,
              event.xconfigure.width,
              event.xconfigure.height
            );
            break;
          }
          case Expose:
          {
            break;
          }
          default:
          {
            break;
          }
        }
      } while (XPending(Dply));
      //> Loop(TuWas):
}

Code: Alles auswählen

XFlush(Dply);
XPending(Dply);

Code: Alles auswählen

while (1)
    {
      long lE = XEventsQueued(Dply, QueuedAfterFlush);
      while (lE > 0)
      {
        lE--;
        XNextEvent(Dply, &event);
        switch(event.type)
        {
          case KeyPress:
          {
            exit(0);
            break;
          }
          case ConfigureNotify:
          {
            glViewport
            (
              0,
              0,
              event.xconfigure.width,
              event.xconfigure.height
            );
            break;
          }
          case Expose:
          {
            break;
          }
          default:
          {
            break;
          }
        }
      }
      XFlush(Dply);
      //>Loop(TuWas);
}

Code: Alles auswählen

    #ifdef ZWIANER_SDL
      k_dZeit = SDL_GetTicks();
    #else
      timeval tv;
      gettimeofday(&tv, 0);
      k_dZeit = ((double)tv.tv_sec * 1000.0);
      k_dZeit += ((double)tv.tv_usec / 1000.0);
    #endif

Code: Alles auswählen

  unsigned long ulLoop = 0;
  double dZeit1 = pZeit->GetdZeit();   //> Ohne SDL:
  double dZeit2 = SDL_GetTicks();
  double dDiff1 = dZeit1;
  double dDiff2 = dZeit2;
  while (ulLoop < 100000) //LONG_MAX)
  {
    ulLoop++;
    if ((ulLoop % 10000) == 0)
    {
      dZeit1 = pZeit->GetdZeit();   //> Ohne SDL:
      dZeit2 = SDL_GetTicks();
      KTRACE
      (
        "Zeit(Kempter/SDL): %0.5f / %0.5f\n",
        (dZeit1 - dDiff1),
        (dZeit2 - dDiff2)
      );
      dDiff1 = dZeit1;
      dDiff2 = dZeit2;
    }
  }

Code: Alles auswählen

//> Auszüge aus dem Quelltext:
class CKString
{
  public:
    CKString(void);
    CKString(const CKString &sKStr);
    CKString(const string &sStr);
    CKString(const char *cStr);
    virtual ~CKString(void);
    //> ... usw:
    CKString operator + (const CKString &sKStr) const;
    CKString operator + (const string &sStr) const;
    CKString operator + (const char *sStr) const;
   //> ... usw:
};
//> Einsatz:
  {
    CString sCa;
    //> sCa = "1" + "2";  //> ???:        //> Fall1c:  
    CString sCb;
    sCa = "a";
    sCb = "b";
    sCa = sCb + "2";                           //> Fall2c:
    sCb = sCa + "1";                           //> Fall3c:
    sCa = "1" + sCb;                           //> Fall4c:
    sCb = "2" + sCa;                           //> Fall5c:
    sCa = "A" + sCb + "B" + "C";          //> Fall6c:
    
    CKString sKa;
    //> sKa = "1" + "2";  //> ???:        //> Fall1k:
    CKString sKb;
    sKa = "a";
    sKb = "b";
    sKa = sKb + "2";                           //> Fall2k:
    sKb = sKa + "1";                           //> Fall3k:
    //sKa = "1" + sKb;                       //> Fall4k:
    //sKb = "2" + sKa;                       //> Fall5k:
    //sKa = "A" + sKb + "B" + "C";      //> Fall6k:
  }

Code: Alles auswählen

class CKString {

  CKString(const char*) {
     ...
  }

   CKString& operator += (const CKString& other) {
       ...
       return *this;
   }

};

CKString operator+ (const CKString& a, const CKString& b) {
   return CKString(a) += b;
}

Code: Alles auswählen

sKa = sKb + "A" + "B" + "C";  //> OK:
sKa = "A" + sKb + "B" + "C";  //> Funktioniert nicht:

Code: Alles auswählen

CKString operator+ (const CKString& a, const CKString& b) {}

Code: Alles auswählen

// Variante 1
class Bla
{
  Bla operator + (const Bla& dasAndereBla) const;
}

// ist gleichwertig mit einem freien Operator der Art
Bla operator + (const Bla& dasEineBla, const Bla& dasAndereBla);

Code: Alles auswählen

//> *.h, nach der Klassendeklaration:
//> Freie operatoren:
CKString operator + (const char *cStr, const CKString &sKStr) const;
//> *.cpp, nach der Klassenimplementation:
//> Freie Operatoren:
CKString operator + (const char *cStr, const CKString &sKStr) const
{
  string sS(cStr);
  sS.append(sKStr.GetcStr());
  return sS;
}

Code: Alles auswählen

string k_sStr;
const char *CKString::GetcStr(void) const
{
  return k_sStr.c_str();
}
string CKString::Format(const CKString &sKStr, ...)
{
  const char *pFrm = sKStr.GetcStr();
  va_list Argm;
  va_start(Argm, pFrm);
  k_sStr = KFormatArgmList(pFrm, Argm);
  k_iStrLen = k_sStr.length();
  va_end(Argm);
  return k_sStr;
}
string CKString::Format(const char *pFrm, ...)
{
  va_list Argm;
  va_start(Argm, pFrm);
  k_sStr = KFormatArgmList(pFrm, Argm);
  k_iStrLen = k_sStr.length();
  va_end(Argm);
  return k_sStr;
}
//> Einsatz:
CKString sK1;
CKString sK2 = "\nTest: %0.2f";
sK1.Format(sK2, 100.0);   //> Fall1:
sK1.Format(sK2.GetcStr(), 100.0); //> Fall2:
sK1.Format("\nTest: %0.2f", 100.0); //> Fall3

Code: Alles auswählen

va_start(Argm, pFrm); // sollte wohl eher sKStr anstelle von pFrm sein

Code: Alles auswählen

class CKString
{
  public:
    CKString(void);
    CKString(const CKString &sKStr);
    CKString(const string &sStr);
    CKString(const char *cStr);
    virtual ~CKString(void);
    // ...
    int Compare(const CKString &sKStr) const;
    //> int Compare(const string &sStr) const;
    //> int Compare(const char *cStr) const;
    // oder
    bool operator == (const CKString &sKStr) const;
    //> bool operator == (const string &sStr) const;
    //> bool operator == (const char *cStr) const;
    // ...
};

Code: Alles auswählen

CKString s;
bool b = s == "Hi!";