játékfejlesztés.hu
FórumGarázsprojectekCikkekSegédletekJf.hu versenyekKapcsolatokEgyebek
Legaktívabb fórumozók:
Asylum:    5440
FZoli:    4892
Kuz:    4455
gaborlabor:    4449
kicsy:    4304
TPG:    3402
monostoria:    3284
DMG:    3172
HomeGnome:    2919
Matzi:    2519

Pretender:    2498
szeki:    2440
Seeting:    2306
Geri:    2185
Orphy:    1893
Joga:    1791
Bacce:    1783
MaNiAc:    1735
ddbwo:    1625
syam:    1491
Frissebbek | Korábbi postok
[1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [15] [20] > 25 < [30] [35] [40] [45] [50] [55] [60] [65] [70] [75] [80] [85] [90] [95] [100] [105] [110] [115] [120] [125] [130] [135] [140] [141]
versio - Tag | 659 hsz       Online status #177909   2012.04.08 16:08 GMT+1 óra  
mindenkinek megvan a sajat kodolasi stilusa, az enyem ilyen
   
Asylum - Törzstag | 5440 hsz       Online status #177908   2012.04.08 16:06 GMT+1 óra  
Jajj ez a sok vonal ááh...tegye fel a kezét aki lát ebböl bármit is, mert én nem...
És egyébként is ez intrusive_ptr.
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
versio - Tag | 659 hsz       Online status #177906   2012.04.08 15:56 GMT+1 óra  
itt van a pointer osztaly ha valaki ki akarja probalni

Kód:
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Pointer
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#pragma once
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include "Memory.h"
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class Reference
{
public:

//***************************************************************************************************************************************************************
// DATA MEMBERS
//***************************************************************************************************************************************************************
unsigned short ReferenceValue;
//***************************************************************************************************************************************************************
//===============================================================================================================================================================
//CONSTRUCTORS
//===============================================================================================================================================================
Reference() : ReferenceValue(0) {}
//===============================================================================================================================================================

};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
template <class T> class PTR
{
public:

//***************************************************************************************************************************************************************
// DATA MEMBERS
//***************************************************************************************************************************************************************
T* Base;
//***************************************************************************************************************************************************************

public:

//===============================================================================================================================================================
//CONSTRUCTORS
//===============================================================================================================================================================
inline PTR() : Base(0)
{
Base=new T;
}
//===============================================================================================================================================================
//DESTRUCTOR
//===============================================================================================================================================================
inline ~PTR()
{
if(Base->ReferenceValue == 0)
{
delete Base;
}
else Base->ReferenceValue--;
}
//===============================================================================================================================================================
//COPY CONSTRUCTOR
//===============================================================================================================================================================
inline PTR(const PTR &s)
{
Base=s.Base;
Base->ReferenceValue++;
}
//===============================================================================================================================================================
//FUNCTIONS
//===============================================================================================================================================================
inline void operator=(PTR s)
{
if(Base != 0)
{
if(Base->ReferenceValue == 0)
{

delete Base;
}
else Base->ReferenceValue--;
}
Base=s.Base;
Base->ReferenceValue++;
}
//===============================================================================================================================================================
inline T* operator->() { return Base; }
//===============================================================================================================================================================
inline void operator<<(PTR s)
{
if(Base->ReferenceValue == 0)
{
delete Base;
}
else Base->ReferenceValue--;
Base=new T;
*Base=*s;
Base->ReferenceValue=0;
}
//===============================================================================================================================================================
inline void CreateArray(int i)
{
Base=new T[i];
}
//===============================================================================================================================================================
inline void DeleteArray()
{
delete [] Base;
}
//===============================================================================================================================================================
inline void operator=(T* s)
{
if(Base != 0)
{
if(Base->ReferenceValue == 0)
{
delete Base;
}
else Base->ReferenceValue--;
}
Base=s;
Base->ReferenceValue++;
}
//===============================================================================================================================================================
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   
bit.0x8000 - Törzstag | 574 hsz       Online status #177905   2012.04.08 15:53 GMT+1 óra  
Idézet
Seeting :
Vagy például bit, az amiket felsoroltál, írnál melléjük egy-egy példát, hogy egy engine-ben ezeket milyen feladatokra tudnám felhasználni?


A smart pointer és a pointer container a kód átláthatóságát növeli, a lexical_cast-tal szövegfájlokból lehet értékeket beolvasni, a named_mutex-el elérhető (platformfüggetlenül), hogy a programból csak egy példány fusson. De ez csak az, amire én használtam, igazából szerintem neked kéne tudnod, hogyan akarod felépíteni az engine-t, mi az ami "illeszkedik" ehhez, mennyire fontos a platformfüggetlenség, stb.. Mondjuk a C/C++ ilyen szempontból kicsit kaotikus, ugyanazt sokféleképpen is meg lehet oldani, de pont ez adja az erejét...
   
versio - Tag | 659 hsz       Online status #177904   2012.04.08 15:52 GMT+1 óra  
jobb mint a c#, mivel nem kellett new-al sem szarakodni
   
Seeting - Törzstag | 2306 hsz       Online status #177900   2012.04.08 15:42 GMT+1 óra  
Idézet
versio :
ahogy megcsinaltam kiba jo volt programozni vele, semmilyen pointer tipusra nem volt szukseg ,sem referenciara, minden valtozo pointer volt



Akkor olyan volt mint a c#, nem?
   
versio - Tag | 659 hsz       Online status #177899   2012.04.08 15:36 GMT+1 óra  
abszolut nem szokas kerdese, ha peldaul atadsz egy pointert 10 helyre , honnan tudod mikor torolheted? ha kitorlod es valaki megis meghivja elszall a programod, mig smart pointernel automatikusan torlodik ha a referenciak megszunnek

ahogy megcsinaltam kiba jo volt programozni vele, semmilyen pointer tipusra nem volt szukseg ,sem referenciara, minden valtozo pointer volt, es igy nem igenyelt extra jelolest, a az egyetlen problema a lassusag volt, azt sajnos nem tudtam megoldani , de ha rajovok egybol atterek erre mert hihetetlenul fantasztikus
   
Pretender - Törzstag | 2498 hsz       Online status #177898   2012.04.08 15:28 GMT+1 óra  
én nagyon jól megvagyok ilyen bohóckodások nélkül, szerintem meg lehet szokni, hogy new, delete, és kész.

   
versio - Tag | 659 hsz       Online status #177897   2012.04.08 15:16 GMT+1 óra  
Asylum: nekem az volt a celom hogy minden valtozo deklaralaskor letrejojjon, es ne kelljen a new -al letrehozni es termeszetesen deletere sem volt szukseg, a programozas altala nagyon ertheto es egyszeru volt, csak megbukott a sebessegen, sajnos a tobb processzor kozotti cache urites es szinkronizalas kinyirta, pedig nem kellene sok hogy rendesen mukodjon, ha kitudnam olvasni valahonnan hogy az adott kod hanyas magon fut, megoldhato lenne de ilyet nem talaltam, a win8metro meg az assemblyt tiltja
   
Asylum - Törzstag | 5440 hsz       Online status #177894   2012.04.08 14:58 GMT+1 óra  
Ésszel kell használni öket; nem azért vannak, hogy ne kelljen figyelni a deallokálásra, hanem azért hogy bizonyos nehéz esetekben ne kelljen.
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
versio - Tag | 659 hsz       Online status #177893   2012.04.08 14:56 GMT+1 óra  
az a baj ezekkel a smart pointerekkel hogy lassuak , es korulmenyesebbe teszik a debuggolast, en probaltam sajatot irni, es sikerult 30%-os sebesseg csokkenes mellett megoldani, de csakis egy processzormag hasznalatnal., tobbnel a sebesseg exponencialisan csokken ,
a konkluzio az lett hogy fordito tamogatas nelkul lehetetlen megoldani jol, es csak minimalis szinten hasznalom , ahol lehet kerulom
   
Seeting - Törzstag | 2306 hsz       Online status #177891   2012.04.08 14:43 GMT+1 óra  
Idézet
bit.0x8000 :
Egyébként szerintem az a járható út, ha az ember átnézi, és kiválasztja magának...



Thx Asy & bit, de nekem ez még elég új. A pointer containerrel pl csinálhatnék C# szintű ( vagy azt megközelítő ) garbage collectort?

Vagy például bit, az amiket felsoroltál, írnál melléjük egy-egy példát, hogy egy engine-ben ezeket milyen feladatokra tudnám felhasználni?

Szerk: Vagy mi a helyzet a Boost::Geometry-val? Azt miért nem írtad a listába?
   
bit.0x8000 - Törzstag | 574 hsz       Online status #177883   2012.04.08 14:06 GMT+1 óra  
Idézet
Seeting :
Van valakinek tapasztalata a Boost-al? Milyen libeket érdemes belőle használni játék- vagy engine fejlesztéshez?


Igazából a boost-ban nem csak lib-ek vannak, hanem egy csomó template is, ami hasznos lehet.

Amik nekem hasznosak voltak, és most eszembe jutnak:
smart pointer
pointer container
lexical_cast
named_mutex

Egyébként szerintem az a járható út, ha az ember átnézi, és kiválasztja magának...
   
Asylum - Törzstag | 5440 hsz       Online status #177882   2012.04.08 13:58 GMT+1 óra  
Shared_ptr-t lehet (de megirni se nehezebb mint megtanulni). A többit meg vagy használod vagy nem (tipikusan nem).
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
Seeting - Törzstag | 2306 hsz       Online status #177881   2012.04.08 13:36 GMT+1 óra  
Hali!

Van valakinek tapasztalata a Boost-al? Milyen libeket érdemes belőle használni játék- vagy engine fejlesztéshez?
   
Dookle - Tag | 478 hsz       Online status #177840   2012.04.07 15:12 GMT+1 óra  
Megpróbálom ... de most pihenek egyet mert már hányok ettől... ... A gond az hogy az is osszezavar hogy a vonalak felbontása limitált tehát ha 2 pont között a távolság 0.02 azt akkor is 1 pixel különbséggel fogja kirajzolni és ha a távolság 1.0 akkor is 1 pixel különbséggel fogja kirajzolni...

Vagy nem... ?


Szerk :

Na működik !!! Beszoroztam az offsetet de az még nem volt elég neki ... kirajzoltattam vele az offsetet , és rájöttem hogy eltolódik a zoomnál , mert kefelejtettem a translate-et

Ez így nem jó
Kód:
offsetx = offsetx *1.1f;
offsety = offsety *1.1f;


Ez már jó
Kód:
offsetx = ((offsetx - cusrsorpos.x) * 1.1f) + cusrsorpos.x;
offsety = ((offsety - cusrsorpos.y) * 1.1f) + cusrsorpos.y;

Ezt a hozzászólást Dookle módosította (2012.04.07 17:44 GMT+1 óra, ---)
STEVIE RAY VAUGHAN FOREVER !!!!!

http://pinkcatgames.ucoz.com/
   
Asylum - Törzstag | 5440 hsz       Online status #177839   2012.04.07 15:01 GMT+1 óra  
Egérkoordinátát is skálázd be? Meg szerintem az offsetet is.
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
Dookle - Tag | 478 hsz       Online status #177837   2012.04.07 14:47 GMT+1 óra  
Ja elnézést : az offset a teljes kép (graph) elmozdulását mutatja , azaz ha a középső egérgombal mozgatom a képet jobbra balra fel le ( mint a scroll bar)

Nem az nincs rászámolva


nyilván szabványos mátrixokkal könnyebb lenne számolni , de azért választottam ezt a fapados verziót mert sehol a progiban nem fogok mátrixokat használni , ezért külön írni hozzá matek osztályt felesleges lenne... és akkor sem tudnám megoldani
STEVIE RAY VAUGHAN FOREVER !!!!!

http://pinkcatgames.ucoz.com/
   
Asylum - Törzstag | 5440 hsz       Online status #177836   2012.04.07 14:42 GMT+1 óra  
Az offset az mi? Azt is beskálázod zoomoláskor?
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
Dookle - Tag | 478 hsz       Online status #177835   2012.04.07 14:31 GMT+1 óra  


a pontok számítása :

Kód:
void zoomIn()
{
    // pt = cursor client coordinata

    for (std::vector<sPointData>::iterator it = points.begin(); it != points.end(); it++)
    {
        (*it).posx = (((*it).posx - pt.x ) *1.1f) + pt.x;
        (*it).posy = (((*it).posy - pt.y)  *1.1f) + pt.y;
    };
}

void insertPoint()
{
       // pt = cursor client coordinata
       newPoint.x = (pt.x - offsetx);
       newPoint.y = (offsety - pt.y);
}


az insertPoint() addig jó amíg egyszer meg nem hívom a zoomIn()-t onnantól nem stimmelnek a koordináták. Azt szeretném hogy legyen ilyen "finom hangolás" mert ugye amíg
egy egység == egy pixel addig működik a dolog , de amint
egy egység != egy pixel akkor már nem jó a számítás, vagy ha jó akkor rosszul rajzolja ki a pontot (feljebb - lejjebb)


EDIT : Ja az offset a teljes kép (graph) elmozdulását mutatja , azaz ha a középső egérgombal mozgatom a képet jobbra balra fel le ( mint a scroll bar)

Ezt a hozzászólást Dookle módosította (2012.04.07 14:46 GMT+1 óra, ---)
STEVIE RAY VAUGHAN FOREVER !!!!!

http://pinkcatgames.ucoz.com/
   
Asylum - Törzstag | 5440 hsz       Online status #177833   2012.04.07 14:10 GMT+1 óra  
Tudsz mutatni egy képet? Hogyan számolod ki az egérböl hogy hova kerüljön a pont?
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
Dookle - Tag | 478 hsz       Online status #177827   2012.04.07 12:43 GMT+1 óra  
Heló matek zsenik ! Egy kicsit elakadtam. szóval egyszerű grafikont készítek , az alábbi featureokkel :
- a grafikon 2 pontal jön létre , amelyek közé tetszőleges helyre újabb pont illeszthető egér duplaklikkel.
- zoom-in zoom-out (ahol az egér aktuális poziciója a 0,0 , tehát mindíg innen indul a zoomolás)
- egér középső gombal jobbra balra , fel ,le mozdítható a grafikon (offset)

A probléma a következő (remélem érthető lesz)
a zoomolás és a pontok mozgatása már tökéletesen működik ,a pont beillésztés is , mindadigg amíg bele nem zoomolok a grafikonba.... Hogy lehet kiszámolni az új pont koordinátáit ha mondjuk a zoom ratio 1.1f ( azaz a pontok koordinátái-t szorzom be ezzel a számmal így jön létre a zoom .Ha nincs zoomolva akkor értelemszerűen 1.0f a zoom ratio ) Bárhogy próbálom sohasem jó a pont koordinátája.
Biztos vagyok benne hogy van valami aránylag triviális megoldás de egyszerűen nem tudok rájönni

A netet is átkerestem de semmi használhatót nem találtam... az az igázság hogy nem is tudom mit kellene pontosan keresni

Előre is köszi
STEVIE RAY VAUGHAN FOREVER !!!!!

http://pinkcatgames.ucoz.com/
   
Asylum - Törzstag | 5440 hsz       Online status #177818   2012.04.07 10:02 GMT+1 óra  
Az a probléma, hogy C++ tanulás helyett textúrázik...
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
Pretender - Törzstag | 2498 hsz       Online status #177806   2012.04.07 00:22 GMT+1 óra  
fura, nekem nem másolódik...
Kód:
#include <vector>
#include <iostream>

struct apple
{
    int foo;

    apple(const int& _foo)
    {
        foo = _foo;
    }

    void write()
    {
        std::cout << foo << std::endl;
    }
};

int main()
{
    std::vector<apple*> apples;

    apple* egy = new apple(10);
    apple* ketto = new apple(15);

    egy->write(); // 10
    ketto->write(); // 15

    apples.push_back(egy);
    apples.push_back(ketto);

    apples[0]->write(); // 10
    apples[1]->write(); // 15

    egy->foo = 20;

    egy->write(); // 20
    ketto->write(); // 15
    apples[0]->write(); // 20
    apples[1]->write(); // 15

    system("pause");
    return 0;
}


szerk.:
oké, késő van, felfogtam, hogy mi a probléma

   
sheridan - Tag | 55 hsz       Online status #177805   2012.04.06 22:52 GMT+1 óra  
Köszi a válaszokat, gondoltam hogy e miatt van. Megvan az oka miért kell ezt használnom.

   
Parallax - Tag | 574 hsz       Online status #177802   2012.04.06 22:44 GMT+1 óra  
A megoldás vector<CTexture ^> textureList; és nem leak se. Ja, de ez egy másik topicba való.

   
versio - Tag | 659 hsz       Online status #177801   2012.04.06 22:35 GMT+1 óra  
a megoldas :

vector<CTexture**> texturak;

csak ne lokalis valtozo legyen , mert elszall mint gyozelmi
   
Parallax - Tag | 574 hsz       Online status #177799   2012.04.06 22:29 GMT+1 óra  
Kód:
CTexture* egy = new CTexture(.......);
CTexture* harom = new CTexture(.......);

egy = harom;


Én még annyit fűznék ehhez, hogy nem értem ez mire jó. Ha csak nem használsz valamilyen memória managert ez egy szép memory leak lesz.

   
gaborlabor - Moderátor | 4449 hsz       Online status #177796   2012.04.06 22:12 GMT+1 óra  
Idézet
sheridan :
Megtudjátok mondani mit csinál vele az STL vector, hogy nem lehet lecserélni? Hogyan oldható meg?


Amikor az STL vectorba push_back-elsz egy változót, akkor annak az értéke lemásolódik és az kerül be. Tehát később hiába módosítod a pointert, a vectorban lévő pointer ugyanoda fog mutatni, mint előtte.
Le lehet cserélni, csak akkor a vectorban lévő pointert kell módosítani, az meg kb ugyanúgy történik, mintha egy sima tömb egy elemét módosítanád. (megkeresed, felülírod...)

   
gaborlabor - Moderátor | 4449 hsz       Online status #177795   2012.04.06 22:06 GMT+1 óra  
Idézet
Asylum :
Kohhh....ezer byteos packet? Az szerintem fajdalmas lesz...en 64, 128, 256 ot engednek (udp + ip headerrel egyutt).


Miért lesz fájdalmas?
Ha valahol útközben olyan linken halad át a packet, ahol kisebb az MTU mint a packet mérete, csak akkor lesz darabolva.
Manapság meg simán 1000 feletti MTU-kkal találkozni, 1400-1500 körüliek a jellemző értékek.

   
sheridan - Tag | 55 hsz       Online status #177786   2012.04.06 20:50 GMT+1 óra  
Sziasztok!

Lenne egy STL-es kérdésem. Van egy saját textúra osztályom: CTexture. És egy TextureManager osztályom, ahol vector<CTexture*>-ban tárolom a betöltött textúrákat. Egy olyat szerettem volna csinálni röviden írva, hogy pl:

vector<CTexture*> texturak;

CTexture* egy = new CTexture(.......);
CTexture* ketto = new CTexture(.......);

texturak.push_back(egy);
texturak.push_back(ketto);

CTexture* harom = new CTexture(.......);

// Azt szeretném mondjuk az első egy masik textura objektumra mutasson
egy = harom;

Lefordul meg minden, de a texttúra nem cserélődik le.

De ha ezt írom, akkor jó (nyílván):

egy->openglID = harom->openglID;

Megtudjátok mondani mit csinál vele az STL vector, hogy nem lehet lecserélni? Hogyan oldható meg?

   
Pretender - Törzstag | 2498 hsz       Online status #177744   2012.04.06 14:02 GMT+1 óra  
mondtam, hogy lehet, hogy sok kevesebb lesz az, viszont teszthez inkább legyen túl-, mint alábecsülve viszont ha jól számoltam, akkor még 5000 kliens mellett is < 256mb-t foglalna az összes packet

   
Asylum - Törzstag | 5440 hsz       Online status #177741   2012.04.06 13:41 GMT+1 óra  
Kohhh....ezer byteos packet? Az szerintem fajdalmas lesz...en 64, 128, 256 ot engednek (udp + ip headerrel egyutt).
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
Pretender - Törzstag | 2498 hsz       Online status #177734   2012.04.06 12:14 GMT+1 óra  
Valami ilyesmi jutott eszembe nekem is, csak dinamikusan
Előre lefoglalok egy nagy méretű Packet vectort, amelyiknek mindegyik elemének a legnagyobb méretű tömböt foglalom le. Így menet közben nem lesz new meg delete, csak memcpyzgetek mondjuk.

szerk.:
Mondjuk meg van határozva, hogy max. 1000 byte adatot tárolhat egy packet (ami még lehet, hogy túl sok is). Ekkora mennyiséget minden packetnek lefoglalok, azaz kb. 1kb-ot.
Minden egyes klienshez előre elkészítem a packeteket, mondjuk 50db-ot, azaz 1 klienshez 50*1kb = 50kb fog tartozni.
Azaz valami ilyesmi (vázlat)
Kód:
sturct Packet
{
    unsigned char* data;

    Packet()
    {
        data = new unsigned char[HEADER_SIZE + MAX_SIZE]; // ~ 1kb
    }
};

class Connection
{
    vector<Packet*> packets;

    void foo()
    {
        packets.resize(50);
        for (int i = 0; i < 50; i++)
            packets[i] = new Packet();

        // és itt lesz nagyjából 50kb adat.
    }
};

Ezzel kicsit számolgatva, ha 1 kliens ~ 50 kb, akkor ~20 kliens 1mb, azaz mondjuk egy 2gb-s rammal rendelkező szerver esetén ilyen szempontból az akár 5120 kliens (~256mb) meg sem kottyan

Ezt a hozzászólást Pretender módosította (2012.04.06 13:04 GMT+1 óra, ---)

   
Asylum - Törzstag | 5440 hsz       Online status #177730   2012.04.06 11:40 GMT+1 óra  
Csak brainstormolok.
Csinalhatnal minden kliensnek egy cachet ahova csak folytonosan fosodik be az adat (egy circular buffer pl.). Ha nincs tobb hely akkor blokkoljon. A szerver vegigmegy ezeken es mindig kiveszi a legkorabbit mindegyik buffbol (igy kb. mindenki ugyanannyira fog laggolni), es feldolgozza.
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
Pretender - Törzstag | 2498 hsz       Online status #177723   2012.04.06 09:05 GMT+1 óra  
és esetleg memove-okkal? Van egy bufferem, ahova a tényleges adat kerül, és ha az egyik közbülső rész kikerül a kukába, akkor az utána lévő részeket odébbpakolom, így mindig egy egybefüggő blokkom lesz. (a memmove gondolom "jobb", mint a memcpy).
Minden esetre, ha ez így működőképes lesz, akkor is már sokkal jobb lesz, mint mindig új memóriát foglalni meg felszabadítani

szerk.:
Illetve az járható út-e, hogy (vázlatosan)
Kód:
struct Packet
{
    char* data;

    Packet(const int& _size, char* _buff, const int& _offset)
    {
        data = new (_buff + _offset) char[_size];
    }
};

char* buff = new char[500];
char* data = new char[2000];

Packet* p1 = new (buff + 0 * sizeof(Packet)) Packet(10, data, 0);
Packet* p2 = new (buff + 1 * sizeof(Packet)) Packet(20, data, 10);
Packet* p3 = new (buff + 2 * sizeof(Packet)) Packet(15, data, 30);


szerk.2:
persze nekem valami tök más is jó lenne, én csak azt tudom, hogy ettől igencsak kiakad a progi egy idő után, főleg, ha a szerverre rá van csatlakozva 10 kliens, és egyfolytában fossák az adatokat magukból a szerver meg szépen mindig new-ol meg delete-zik.

Ezt a hozzászólást Pretender módosította (2012.04.06 09:32 GMT+1 óra, ---)

   
sirpalee - Tag | 1282 hsz       Online status #177700   2012.04.05 15:04 GMT+1 óra  
Idézet
Pretender :
...



Ez sz..pás, méghozzá nagy. Ideális esetben le akarod managelni az egészet, hogy hova rakhatsz új objektumot, hova nem. Hol vannak a lyukak stb... Ez bonyolódik, ha különböző méretű objektumokat pakolsz a bufferbe. És így tovább.


Idézet
Asylum :
...



Van olyan szituáció, ahol ez hasznos, és nem lehet másként értelmesen megoldani (anélkül, hogy ne rohaszd le az egész rendszert).

Ezt a hozzászólást sirpalee módosította (2012.04.05 15:09 GMT+1 óra, ---)
raytraceisten és übermedic
   
Asylum - Törzstag | 5440 hsz       Online status #177699   2012.04.05 15:03 GMT+1 óra  
Idézet

Kód:
char* buff = new char[2000];

Packet* p1 = new (buff) Packet(10);




Ilyet soha!

Destruktort is soha! delete operatort tessek hasznalni (tudom, h a tutorban nem ugy csinaltam, de el memmove-olom az adatot).

A defragmentalas szinten a te dolgod (javaslok egy deque implementaciot).
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
Parallax - Tag | 574 hsz       Online status #177697   2012.04.05 14:54 GMT+1 óra  
Idézet
versio :
Asylum: naja a microsoft nem szarozott a c++ -al, total szetvagta az egeszet , nem tudom de ezek azt hiszik attol jo egy nyelv ha minel tobbet tud, hasonlattal elve nem is tudom a ferrarira miert nem aggatnak eket, aztan lehetne vele szantani b+

a jo kis pascalos idok , raneztem a kodra es ertettem egybol


Egyszerűsítettek is rajta. Nincs pointerezés, helyette referencia van. Nem kell memória kezeléssel foglalkozni, mégis determinisztikus. Metadatok tárolása, vagyis a netív C++ DLL-edet bindolás nélkül scriptelheted C# ból, vagy javascript-ből. Ötvözték a C# hatékonyságát a C++ sebességével.
Egyébként tényleg külön C++/CX topic kéne neki, mert annyi köze van a C++ hoz, mint a C# nak kb.

   
versio - Tag | 659 hsz       Online status #177696   2012.04.05 14:48 GMT+1 óra  
Asylum: naja a microsoft nem szarozott a c++ -al, total szetvagta az egeszet , nem tudom de ezek azt hiszik attol jo egy nyelv ha minel tobbet tud, hasonlattal elve nem is tudom a ferrarira miert nem aggatnak eket, aztan lehetne vele szantani b+

a jo kis pascalos idok , raneztem a kodra es ertettem egybol
   
Pretender - Törzstag | 2498 hsz       Online status #177689   2012.04.05 13:44 GMT+1 óra  
igen, a destruktort azt néztem, hogy explicit meg lehet (/kell) hívni, nem deletezni.
Aha, értem, akkor kezelni kell az offsetelést, köszi.

No de hogy lehet vajh' értelmesen megoldani az egészet? Gondolok itt arra, hogy mondjuk
Kód:
Alma* a1 = new (buff + 0 * sizeof(Alma)) Alma();
Alma* a2 = new (buff + 1 * sizeof(Alma)) Alma();
Alma* a3 = new (buff + 2 * sizeof(Alma)) Alma();

majd mondjuk a közbülső elemet töröljük
Kód:
a2->~Alma();

Ekkor az a1 és a3 közötti terület "felszabadul", tehát nem elég egy offsetet tárolni. Az meg hülyeség lenne, hogy egy törléskor az utána lévő adatokra tolok egy memcpy-t.

szerk.:
Illetve az ilyen esetben:
Kód:
struct Packet
{
    char* data;

    Packet(const int& _size)
    {
        data = new char[_size];
    }
};

char* buff = new char[2000];

Packet* p1 = new (buff) Packet(10);

a Packet::data is az adott memóriaterületre fog kerülni, vagy mivel az simán new, ezért allokál neki egy újat? (gondolom). Ebben az esetben tehát a new char[_size]-t is módosítani kell?

Ezt a hozzászólást Pretender módosította (2012.04.05 14:12 GMT+1 óra, ---)

   
sirpalee - Tag | 1282 hsz       Online status #177687   2012.04.05 13:42 GMT+1 óra  
Idézet
Asylum :
Placement new ra is kell delete!!!
Es nem bigbuff hanem bigbuff + sizeof(Alma) a masodik.



Mármint arra a memóriaterületre, ahova placement new-al létrehozod a dolgokat, nem a placement new-al létrehozott osztályra (arra csak a destruktort kell meghívni).
raytraceisten és übermedic
   
Asylum - Törzstag | 5440 hsz       Online status #177685   2012.04.05 13:34 GMT+1 óra  
Placement new ra is kell delete!!!
Es nem bigbuff hanem bigbuff + sizeof(Alma) a masodik.
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
Pretender - Törzstag | 2498 hsz       Online status #177684   2012.04.05 13:34 GMT+1 óra  
Visszatérve a netes packetekre. Muszáj maradnia ennek a new Packet(..)-nek, mert így a legszerencsésebb eltárolni az adatokat egy vectorban, de ez így nem jó, mert hébe-hóba, ha nem vs-ből futtatom, akkor elszáll. Múltkor megnéztem és a free.c-ben valami release részre nyom hibát, heap memory-ra hivatkozva

Viszont akkor nézegetem ezt a placement new-t, mert ha jól értem az nem foglal le memóriát, hanem én lefoglalok egy nagy buffert, és oda "rakosgatja". Ezáltal gondolom gyorsabb művelet, mint a "sima" new.

Tehát valami ilyesmi lehet (ha jól értem "magától" kezeli a pointereket)
Kód:
char* bigbuff = new char[2000];

struct Alma
{
    int foo;

    Alma(const int& _foo)
    {
        foo = _foo;
    }
};

Alma* a1 = new (bigbuff) Alma(10);
Alma* a2 = new (bigbuff) Alma(20);

std::cout << a1->foo << a2->foo << std::endl;

   
Asylum - Törzstag | 5440 hsz       Online status #177683   2012.04.05 13:33 GMT+1 óra  
Topicot tevesztettel, itt C++ rol szoktunk beszelni nem microfos++ rol.
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
versio - Tag | 659 hsz       Online status #177631   2012.04.04 23:39 GMT+1 óra  
Kód:
void ReadTextAsync(Platform::String^ filename,function<void (const wchar_t*,int)> callback)
{
Concurrency::task<Windows::Storage::StorageFile^>(m_location->GetFileAsync(filename)).then([=](Windows::Storage::StorageFile^ file)
{
return Windows::Storage::FileIO::ReadTextAsync(file);
}).then([=](Platform::String^ fileContent)
{
callback(fileContent->Data(),fileContent->Length());
});
}


nincs valakinek otlete hogy a PlatformString^ smart pointert hogy kuldjem vissza a lambda Callback funkcionak, mert parameterben baszik elfogadni
   
proof88 - Törzstag | 528 hsz       Online status #177380   2012.04.01 14:25 GMT+1 óra  
néha nem árt berakni egy breakpoint-ot és debugolni hogy mi is történik pontosan
   
versio - Tag | 659 hsz       Online status #177378   2012.04.01 14:20 GMT+1 óra  
az elso esetben a a rendszer keres egy memoria teruletet ami ures, es lefoglalja az alma meretet
a masodik esetben rateszi a veremre, ami sokkal gyorsabb muvelet, mivel nem kell keresnie semmit
   
Asylum - Törzstag | 5440 hsz       Online status #177377   2012.04.01 14:16 GMT+1 óra  
A második esetben létrehozod az objektumot, majd létrehozol egy temporárist, majd meghívódik a copy konstruktor és a temporáris megsemmisül.
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
Pretender - Törzstag | 2498 hsz       Online status #177368   2012.04.01 12:47 GMT+1 óra  
ja, az se rossz, adott bufferbe rakosgatni. De ha mondjuk van egy Alma struktúrám, és nem azt írom, hogy
Kód:
Alma* alma = new Alma(...);

hanem
Kód:
Alma alma = Alma(...);

akkor ebben az esetben hol foglalódik le a memória, vagy mi történik?

   
Frissebbek | Korábbi postok
[1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [15] [20] > 25 < [30] [35] [40] [45] [50] [55] [60] [65] [70] [75] [80] [85] [90] [95] [100] [105] [110] [115] [120] [125] [130] [135] [140] [141]