gabaman

Hozzászólások

10 bejegyzés megtekintése - 411-420 / 2,173
  • Szerző
    Bejegyzés
  • gabaman
    Felhasználó

      „Véget érhet a Microsoft magyarországi monopóliuma az állami szektorban.”

      Inkább csak a döntéshozók kezdik felfedezni, hogy van élet a Microsoft nélkül is… A régebbi MS EULA (szoftver licenc) tasakokon volt egy felirat, hogy „felbontása automatikus elfogadással jár”. A megboldogult HwHunPage oldalon volt egy jó kép róla (sajna már nem találom). Lehet hogy a GKM a jövő évi szerződést már nem az aláírása után szeretné elolvasni?

      Hozzászólás: Maximális swap #2139506
      gabaman
      Felhasználó
        —Laszlo— wrote:
        Nincs lehetőség rá hogy 2Gb -nál nagyobb swap -et hozzunk létre ?  Ha jól tudom ez alapban a felső határ.

        A maximális swap terület 32*64GB.

        http://www.novell.com/linux/techspecs.html -> Kernel Limits

        Hozzászólás: Maximális swap #2139507
        gabaman
        Felhasználó
          —Laszlo— wrote:
          Nincs lehetőség rá hogy 2Gb -nál nagyobb swap -et hozzunk létre ?  Ha jól tudom ez alapban a felső határ.

          A maximális swap terület 32*64GB.

          http://www.novell.com/linux/techspecs.html -> Kernel Limits

          Hozzászólás: Hogy jöhet ki egy header lgpl oltalma alatt? #2139242
          gabaman
          Felhasználó

            Nekem úgy tűnik, hogy akkor alkalmazandóak a fenti szabályok (a. és b.), ha egy GPL (+ GPL kompatibilis) vagy kereskedelmi (zárt) szoftvert együttműködő fejléceit (incorporate headers) akarod külön LGPL licenc alá helyezni, hogy zárt és nyílt szoftverek egyaránt használhassák. Az általad kiemelt rész azokat a kivételeket tartalmazza, amelyekre (a globális szabad szoftveres – és európai viszonylatban normál – felfogásban) nem vonatkozik szerzői jogi védelem: numerikus paraméterek, adat struktúra elrendezés és hozzáférés, rövid (tíz vagy kevesebb  sor hosszúságú) makrók, beépülő funkciók és sablonok. Szerintem ez egy védelem, hogy ne lehessen triviális dolgok miatt perelgetni. Pl. ha írsz egy makrót, ami két vagy több értéket felcserél (swap), akkor ne lehessen zaklatni másokat, akik ugyanúgy valósítják meg.

            Hozzászólás: Hogy jöhet ki egy header lgpl oltalma alatt? #2139243
            gabaman
            Felhasználó

              Nekem úgy tűnik, hogy akkor alkalmazandóak a fenti szabályok (a. és b.), ha egy GPL (+ GPL kompatibilis) vagy kereskedelmi (zárt) szoftvert együttműködő fejléceit (incorporate headers) akarod külön LGPL licenc alá helyezni, hogy zárt és nyílt szoftverek egyaránt használhassák. Az általad kiemelt rész azokat a kivételeket tartalmazza, amelyekre (a globális szabad szoftveres – és európai viszonylatban normál – felfogásban) nem vonatkozik szerzői jogi védelem: numerikus paraméterek, adat struktúra elrendezés és hozzáférés, rövid (tíz vagy kevesebb  sor hosszúságú) makrók, beépülő funkciók és sablonok. Szerintem ez egy védelem, hogy ne lehessen triviális dolgok miatt perelgetni. Pl. ha írsz egy makrót, ami két vagy több értéket felcserél (swap), akkor ne lehessen zaklatni másokat, akik ugyanúgy valósítják meg.

              Hozzászólás: C++ probléma #2139156
              gabaman
              Felhasználó
                vizsla wrote:
                Helyesen így néz ki a kód:

                Code:
                class Vector3D {
                  /* … */
                }

                Vector3D operator* ( const Vector3D & _src1, const Vector3D & _src2 ) {
                  Vector3D * _dst = NULL;

                  try {
                    _dst = new Vector3D ( /* … */ );
                  } catch ( /* … */ ) {
                    /* … */
                  }

                  std::auto_ptr __dst ( _dst ); // (1)
                  /* … */

                  return * _dst;
                }

                Ha feladjuk a szálbiztos felépítést, akkor egyszerűbb és hatékonyabb ez a kód:

                Code:
                class Vector3D {
                  /* … */
                }

                Vector3D operator* ( const Vector3D & _src1, const Vector3D & _src2 ) {
                  static Vector3D _dst;

                  /* … */

                  return  _dst;
                }

                De így se kerülhetjük el a visszatérési érték egyenkénti másolgatását, hacsak nem használunk tömböt az egyenkénti vagy csoportos műveletekhez:

                Code:
                // Absztakt osztály
                class Vector3D {
                  public:
                    virtual ~Vector3D ();

                    virtual Vector3D operator* ( const Vector3D & _src1, const Vector3D & _src2 ) const=0;
                };

                // A klasszikus Vector3D implementáció; független
                class Vector3DStatic: public Vector3D {
                  private:
                    float x;
                    float y;
                    float z;
                  public:
                    virtual ~Vector3DStatic ();

                    virtual Vector3D operator* ( const Vector3D & _src1, const Vector3D & _src2 ) const;
                    Vector3DStatic operator* ( const Vector3DStatic & _src1, const Vector3DStatic & _src2 ) const;
                };

                // Egy Vector3D tömb eleme, függ a tömbtöl, de viszont gyors és hatékony
                class Vector3DArrayItem: public Vector3D {
                  private:
                    float *item;  // float triplet, mutató a Vector3DArray::store egyik elemére
                  public:
                    virtual ~Vector3DArrayItem ();

                    virtual Vector3D operator* ( const Vector3D & _src1, const Vector3D & _src2 ) const;
                    Vector3DArrayItem operator* ( const Vector3DArrayItem & _src1, const Vector3DArrayItem & _src2 ) const;
                };

                // A Vector3D tömb implementációja
                class Vector3DArray {
                  private:
                    size_t size;
                    float *store;  // Hossz: size*3;
                  public:
                    Vector3DArray (size_t _size);
                  ~Vector3DArray ();

                    Vector3DArrayItem operator[] (size_t _pos) const;
                    float[3] raw (size_t _pos);
                    Vector3DArray operator* ( const Vector3DArray & _src1, const Vector3DArray & _src2 ) const;
                    Vector3DArray subarray (size_t _start size_t _end) const;
                };

                Hozzászólás: C++ probléma #2139157
                gabaman
                Felhasználó
                  vizsla wrote:
                  Helyesen így néz ki a kód:

                  Code:
                  class Vector3D {
                    /* … */
                  }

                  Vector3D operator* ( const Vector3D & _src1, const Vector3D & _src2 ) {
                    Vector3D * _dst = NULL;

                    try {
                      _dst = new Vector3D ( /* … */ );
                    } catch ( /* … */ ) {
                      /* … */
                    }

                    std::auto_ptr __dst ( _dst ); // (1)
                    /* … */

                    return * _dst;
                  }

                  Ha feladjuk a szálbiztos felépítést, akkor egyszerűbb és hatékonyabb ez a kód:

                  Code:
                  class Vector3D {
                    /* … */
                  }

                  Vector3D operator* ( const Vector3D & _src1, const Vector3D & _src2 ) {
                    static Vector3D _dst;

                    /* … */

                    return  _dst;
                  }

                  De így se kerülhetjük el a visszatérési érték egyenkénti másolgatását, hacsak nem használunk tömböt az egyenkénti vagy csoportos műveletekhez:

                  Code:
                  // Absztakt osztály
                  class Vector3D {
                    public:
                      virtual ~Vector3D ();

                      virtual Vector3D operator* ( const Vector3D & _src1, const Vector3D & _src2 ) const=0;
                  };

                  // A klasszikus Vector3D implementáció; független
                  class Vector3DStatic: public Vector3D {
                    private:
                      float x;
                      float y;
                      float z;
                    public:
                      virtual ~Vector3DStatic ();

                      virtual Vector3D operator* ( const Vector3D & _src1, const Vector3D & _src2 ) const;
                      Vector3DStatic operator* ( const Vector3DStatic & _src1, const Vector3DStatic & _src2 ) const;
                  };

                  // Egy Vector3D tömb eleme, függ a tömbtöl, de viszont gyors és hatékony
                  class Vector3DArrayItem: public Vector3D {
                    private:
                      float *item;  // float triplet, mutató a Vector3DArray::store egyik elemére
                    public:
                      virtual ~Vector3DArrayItem ();

                      virtual Vector3D operator* ( const Vector3D & _src1, const Vector3D & _src2 ) const;
                      Vector3DArrayItem operator* ( const Vector3DArrayItem & _src1, const Vector3DArrayItem & _src2 ) const;
                  };

                  // A Vector3D tömb implementációja
                  class Vector3DArray {
                    private:
                      size_t size;
                      float *store;  // Hossz: size*3;
                    public:
                      Vector3DArray (size_t _size);
                    ~Vector3DArray ();

                      Vector3DArrayItem operator[] (size_t _pos) const;
                      float[3] raw (size_t _pos);
                      Vector3DArray operator* ( const Vector3DArray & _src1, const Vector3DArray & _src2 ) const;
                      Vector3DArray subarray (size_t _start size_t _end) const;
                  };

                  Hozzászólás: C++ probléma #2139154
                  gabaman
                  Felhasználó
                    FLINX wrote:
                    Üdv.

                    Csatoltam egy C++ kódot, amire a g++ a következő hibaüzenetet adja:

                    Code:
                    test.cpp: In member function ‘bool Sphere::Intersect(const Ray&, HitRec*)’:
                    test.cpp:74: error: passing ‘const Vector3D’ as ‘this’ argument of ‘Vector3D Vector3D::operator-(Vector3D)’ discards qualifiers
                    test.cpp:76: error: passing ‘const Vector3D’ as ‘this’ argument of ‘float Vector3D::operator*(Vector3D)’ discards qualifiers
                    test.cpp:97: error: passing ‘const Vector3D’ as ‘this’ argument of ‘Vector3D Vector3D::operator*(float)’ discards qualifiers
                    test.cpp:97: error: passing ‘const Vector3D’ as ‘this’ argument of ‘Vector3D Vector3D::operator+(Vector3D)’ discards qualifiers

                    Ami röveden annyi, hogy az említett függvényben egy konstans Vector3D objektumot nem tud átadni this argumentumként a felsorolt operátor függvényeknek…

                    A C++ nyelvben ha egy objektom konstans minősítésű (itt: konstans paraméter), akkor csak a konstans metódusokat lehet elérni, jelenleg ez a baja a GCC fordítónak. Megoldás: használj ‘const’ minősítőt az objektumot nem módosító metódusoknál.

                    Code:
                    Vector3D operator=(const Vector3D& v); // Módosít, nem konstans metódus

                    Vector3D operator+( Vector3D v) const; // Nem módosít, ‘const’ utóminősítőt kapott
                    Vector3D operator-( Vector3D v) const;

                    Vector3D operator*(const float f) const ;
                    Vector3D operator/(const float f) const;

                    float operator*(const Vector3D v) const   {return x*v.x+y*v.y+z*v.z;} //skaláris szorzat
                    float Length() const   {return (float)sqrt(x*x+y*y+z*z);}
                    float* GetArray() const     {return &x; } // struktúra kezdőcíme (nem kontsans objektumból meghívva)
                    const float* GetArray() const   {return &x; } // struktúra kezdőcíme (konstans objektumból meghívva)

                    FLINX wrote:
                    A kódban máshol használom ezeket az operátor függvényeket, és arra nem jelent hibát…
                    Pedig elvileg itt is ugyanolyan Vector3D illetve float argumentumokkal próbálok kiértékelni műveleteket, mint máshol.

                    Ez azért van.mert a többi helyen nem konstans objektum metódusát hívod, a ‘bool Sphere::Intersect(const Ray&, HitRec*)’ metódus ‘ray’ paramétere meg konstans. Ha a fenti minősitőket hsználod, akkor már nem lesz gond.

                    Hozzászólás: C++ probléma #2139155
                    gabaman
                    Felhasználó
                      FLINX wrote:
                      Üdv.

                      Csatoltam egy C++ kódot, amire a g++ a következő hibaüzenetet adja:

                      Code:
                      test.cpp: In member function ‘bool Sphere::Intersect(const Ray&, HitRec*)’:
                      test.cpp:74: error: passing ‘const Vector3D’ as ‘this’ argument of ‘Vector3D Vector3D::operator-(Vector3D)’ discards qualifiers
                      test.cpp:76: error: passing ‘const Vector3D’ as ‘this’ argument of ‘float Vector3D::operator*(Vector3D)’ discards qualifiers
                      test.cpp:97: error: passing ‘const Vector3D’ as ‘this’ argument of ‘Vector3D Vector3D::operator*(float)’ discards qualifiers
                      test.cpp:97: error: passing ‘const Vector3D’ as ‘this’ argument of ‘Vector3D Vector3D::operator+(Vector3D)’ discards qualifiers

                      Ami röveden annyi, hogy az említett függvényben egy konstans Vector3D objektumot nem tud átadni this argumentumként a felsorolt operátor függvényeknek…

                      A C++ nyelvben ha egy objektom konstans minősítésű (itt: konstans paraméter), akkor csak a konstans metódusokat lehet elérni, jelenleg ez a baja a GCC fordítónak. Megoldás: használj ‘const’ minősítőt az objektumot nem módosító metódusoknál.

                      Code:
                      Vector3D operator=(const Vector3D& v); // Módosít, nem konstans metódus

                      Vector3D operator+( Vector3D v) const; // Nem módosít, ‘const’ utóminősítőt kapott
                      Vector3D operator-( Vector3D v) const;

                      Vector3D operator*(const float f) const ;
                      Vector3D operator/(const float f) const;

                      float operator*(const Vector3D v) const   {return x*v.x+y*v.y+z*v.z;} //skaláris szorzat
                      float Length() const   {return (float)sqrt(x*x+y*y+z*z);}
                      float* GetArray() const     {return &x; } // struktúra kezdőcíme (nem kontsans objektumból meghívva)
                      const float* GetArray() const   {return &x; } // struktúra kezdőcíme (konstans objektumból meghívva)

                      FLINX wrote:
                      A kódban máshol használom ezeket az operátor függvényeket, és arra nem jelent hibát…
                      Pedig elvileg itt is ugyanolyan Vector3D illetve float argumentumokkal próbálok kiértékelni műveleteket, mint máshol.

                      Ez azért van.mert a többi helyen nem konstans objektum metódusát hívod, a ‘bool Sphere::Intersect(const Ray&, HitRec*)’ metódus ‘ray’ paramétere meg konstans. Ha a fenti minősitőket hsználod, akkor már nem lesz gond.

                      Hozzászólás: Port megnyitása #2138156
                      gabaman
                      Felhasználó

                        Azt is figyelembe kell venni, hogy néhány ISP ádáz küzdelmet vív a fájlcserélőkkel, ezért bizonyos portokat nagyon belassítanak. Mivel még nem írtad a szolgáltatód nevét, csakk tippelni lehet, hogy releváns-e ez a körülmény. Ha igen, akkor a port átírásával lehet próbálkozni, de az MSN fájlátvitelt protokoll alapján is lehet szűrni, azaz a portszám megváltoztatása ez esetben hatástalan (ha ezt használják). Tesztnek akár a Bittorrent-tel is kipróbálhatod, lassú-e az átvitel.

                      10 bejegyzés megtekintése - 411-420 / 2,173