Hozzászólások
-
SzerzőBejegyzés
-
„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?
—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
—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
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.
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.
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;
};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;
};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 qualifiersAmi 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ódusVector3D 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.
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 qualifiersAmi 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ódusVector3D 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.
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.
-
SzerzőBejegyzés

legutóbbi hsz