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

Pretender:    2498
szeki:    2440
Seeting:    2306
Geri:    2196
Orphy:    1893
Joga:    1791
Bacce:    1783
MaNiAc:    1735
ddbwo:    1654
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] [142]
sirpalee - Tag | 1282 hsz       Online status #177960   2012.04.08 20:32 GMT+1 óra  
Asylum : az már inkább a c# / dotnet hibája...

Nem akarom nagyon védeni, de nem olvastam róla vészeseket. De version "kollega" biztos el tudja magyarázni miért is szörnyű.
raytraceisten és übermedic
   
Asylum - Törzstag | 5484 hsz       Online status #177959   2012.04.08 20:24 GMT+1 óra  
A Force Unleashed elég jól futott vele (mondjuk nem annyira jól mint elvárható lett volna, de na).
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
versio - Tag | 673 hsz       Online status #177958   2012.04.08 20:14 GMT+1 óra  
sirpalee: az egy kupac tragya
   
Seeting - Törzstag | 2306 hsz       Online status #177957   2012.04.08 20:11 GMT+1 óra  
Idézet
Parallax :
Mert futási időben fejtődik ki a generic, míg a template fordítási idejű, ennyi.



Oké, de miért? Miért nem lehet olyan mint a C++?
   
sirpalee - Tag | 1282 hsz       Online status #177956   2012.04.08 20:07 GMT+1 óra  
Miért ne? Ott a slimdx, mindent tud...
raytraceisten és übermedic
   
versio - Tag | 673 hsz       Online status #177955   2012.04.08 20:03 GMT+1 óra  
Parallax:"De egyébként C# és C++ közt azért egyszerűbb projectnél nincs márvadó különbség, csak azért nyelvet váltani fölösleges"


kellett a directx , xna ugyebar nincs, de most nehogy felhozd hogy valami wrapperen keresztul tutujgassam a dx-et , mert a kardomba dolok
   
Parallax - Tag | 606 hsz       Online status #177953   2012.04.08 19:43 GMT+1 óra  
Idézet
Seeting :
Én akkor csalódtam először a C#-ban, amikor munka közben jöttem rá, hogy nem lehet generic típusból osztályt származtatni. Mert azt például értem, hogy miért nem engedi hogy egy osztálynak két szülője legyen, de azzal nem értek egyet, hogy genericből nem tud örököltetni. Egyszerűen nem látom az okát miért...


Mert futási időben fejtődik ki a generic, míg a template fordítási idejű, ennyi.

   
Parallax - Tag | 606 hsz       Online status #177952   2012.04.08 19:39 GMT+1 óra  
version: a #pragma region-t már rég feltalálták, ha VS11-ben dolgozol ott még működik is!
Ha a parallel futtatásra gondolsz "több magos futtatás" alatt, az ugyanannak a wrapperelt változata, ami VC++ hoz is van. Az asszinkronos cucc pedig VS11-nél WinRT-s dolog, ami még javascript-ből is elérhető. A hieroglifa lambda pedig szabványos C++11, nem MS találmány. A CX a mem kezelés és metadatokat oldja meg + delegate, event property stb. De egyébként C# és C++ közt azért egyszerűbb projectnél nincs márvadó különbség, csak azért nyelvet váltani fölösleges. A Soulcraft mobilos 3D játék C# ban írták, teljesen jól fut. Ha ennél jobbat írsz, ami kész és működik is megemelem a kalapom.

   
Asylum - Törzstag | 5484 hsz       Online status #177951   2012.04.08 19:37 GMT+1 óra  
Köhh persze a headerben kifejtett implementációval...hagyjuk már a mesét...
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
Seeting - Törzstag | 2306 hsz       Online status #177950   2012.04.08 19:34 GMT+1 óra  
Én akkor csalódtam először a C#-ban, amikor munka közben jöttem rá, hogy nem lehet generic típusból osztályt származtatni. Mert azt például értem, hogy miért nem engedi hogy egy osztálynak két szülője legyen, de azzal nem értek egyet, hogy genericből nem tud örököltetni. Egyszerűen nem látom az okát miért...

Más szempontból viszont azt tapasztalom, hogy a C#-ban sokkal könnyebb elegánsabb kódot írni, mint C++-ban.
   
versio - Tag | 673 hsz       Online status #177946   2012.04.08 18:45 GMT+1 óra  
a c# egyetlen problemaja, hogy nem lesz 8 magos processzor , es ahhoz hogy a compiler es a garbagecollector eroforrasigenyet elfedje ennyi vagy tobb kell, ez a sweat spot , legalabbis az amhdal grafikonrol ez lathato
de mivel a gyartok letojjak a procimagokat es a gpu-t nyomatjak , igy a c# sajnos vakvagany egyelore, en is ezert tertem vissza c++-ra, itt viszont nincs compiler , csak a garbage collector, es elmeletileg 4 magon is kepes csodakra ,
termeszetesen kezzel mindent jobban meglehet buvolni, csak a kod valik olvashatatlanna, ami hosszutavon nem celszeru
   
Pretender - Törzstag | 2498 hsz       Online status #177945   2012.04.08 18:41 GMT+1 óra  
A c# kód sohasem lesz gyorsabb, de ezt már kitárgyaltuk párszor itt

   
sirpalee - Tag | 1282 hsz       Online status #177944   2012.04.08 18:36 GMT+1 óra  
Ti ketten vagytok még natív mágusok (jó persze vannak még, de ők nem szokták szidni a c#-ot)
raytraceisten és übermedic
   
Asylum - Törzstag | 5484 hsz       Online status #177943   2012.04.08 18:34 GMT+1 óra  
Geri nemtom mért van a zárójelben
Én nem tudom mit csinál meg mit nem csinál a C#, én teljesítménykritikus programokhoz nem fogom használni (kivéve ha fizetnek).
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
sirpalee - Tag | 1282 hsz       Online status #177942   2012.04.08 18:32 GMT+1 óra  
Idézet
versio :
biztos emlexel , regebben irtam hogy a c# kod tobb magon kepes agyonkalapalni a c++-t , kulonbozo optimalizaciok reven, es ehhez csak plusz jarulek a jobban olvashato kod, es hibaturobb futas,



Ezen csak röhögni tudok. És szerintem nem csak én (Asylum, Geri? )
raytraceisten és übermedic
   
versio - Tag | 673 hsz       Online status #177941   2012.04.08 18:30 GMT+1 óra  
biztos emlexel , regebben irtam hogy a c# kod tobb magon kepes agyonkalapalni a c++-t , kulonbozo optimalizaciok reven, es ehhez csak plusz jarulek a jobban olvashato kod, es hibaturobb futas,
namost ez c++ alatt is megoldhato , elmeletileg, ha nem szivat meg a parhuzamos szinkronizalas, termeszetesen ehhez egy specialis garbage collector es optimalizalo kod is kell
   
sirpalee - Tag | 1282 hsz       Online status #177939   2012.04.08 18:26 GMT+1 óra  
Jól sejtetted, semennyiért.

Relatíve ritkán foglalok memóriát, ha mégis, akkor nem teljesítménykritikus kódrészben. (meg nálam általában sosem a memóriafoglalás a kritikus rész, kevesebb mint 1%-al meg nem fogok baszakodni)

Szerk : Lehet a c# kényelmes, de nem hatékony. A c++ képes egész hatékonyan hozzáférést nyújtani az alattad megbúvó hardverhez, van akinek ez kell. Szeretem, ha pontosan azt csinálja a gép, amit szeretnék (és nekem kell is, ha másodpercenként ki kell számolni valamit pár milliószor). Lehet sokat kell szórakozni vele kézzel, vagy optimizálgatni különböző platformokra, de inkább ez, mint hogy kivegyék a kezemből a memóriakezelést, vagy az SSE elérést.
raytraceisten és übermedic
   
versio - Tag | 673 hsz       Online status #177937   2012.04.08 18:07 GMT+1 óra  
sirpalee: itt az a kerdes hogy mekkora sebesseg csokkenes aran mondanal le a pointer kezeles gyonyoreirol?
persze lehet hogy te semennyiert, de aki hasznalt c#-t es hozzaszokott a kenyelemhez annak sokat szamit

de peldaul az ilyan strukturaknal ha a kulonbozo osztalyokat kulon tombokbol foglalod akkor egy olyan kodnal ahol csak az egyik elemet kerdezed le, a smart pointeres kod szarra veri a c++-t

struct
{
ALMA alma;
KORTE korte;
SZILVA szilva;
}
   
sirpalee - Tag | 1282 hsz       Online status #177935   2012.04.08 17:58 GMT+1 óra  
Ezeket a trükköket évek óta csinálják mások, szóval nem nagy szám... Én is szoktam ilyesmikkel trükközni, ha nagyon teljesítménykritikus a kód.
raytraceisten és übermedic
   
versio - Tag | 673 hsz       Online status #177934   2012.04.08 17:51 GMT+1 óra  
viszont most lehet megtalaltam a megoldast

Kód:
int b[4];

for (int a = 0; a < 5; a++)
{
__cpuid(b,a);
}


meg a vegen osszejon a cucc
   
versio - Tag | 673 hsz       Online status #177933   2012.04.08 17:32 GMT+1 óra  
sirpalee: annak fenyeben tenyleg sok hogy nem is hasznalom ,ugyebar tobb processel lassu , anelkul meg szart se er , sajnos a semaphore varas es cache urites teljesen hazavagja
olyan trukk kellene hogyha tudjuk a procresszor mag szamat amin fut a process akkor az ahhoz tartozo kulonallo tombol lehet memoriat foglalni

a rendszer hivas altali memoria foglalas termszetesen parhuzamosan korrekt, de olyan lassu mint az allat
   
Asylum - Törzstag | 5484 hsz       Online status #177930   2012.04.08 17:16 GMT+1 óra  
sirpalee - Tag | 1282 hsz       Online status #177929   2012.04.08 17:02 GMT+1 óra  
Idézet
versio :
sirpalee: xd, a pointer osztaly durvan optimalizalt ,mivel minden valtozo meghivja ha tortenik vele valami, pl fuggveny parameter aradaskor, adatelem eleresnel, masolaskor stb
ez a kod 3 het munka eredmenye, es csak 30%-al lassabb mint a sima c, es ez adattombre is ervenyes, merd le a c# sebesseget es csodalkozz



3 héééééét?

raytraceisten és übermedic
   
Asylum - Törzstag | 5484 hsz       Online status #177927   2012.04.08 17:00 GMT+1 óra  
Erröl a << röl jutott eszembe hogy anno irtam egy collective_ptr osztályt ami olyan shared_ptr aminek le lehet cserélni az általa mutatott értéket. És még müködött is. Közszemlére felteszem minnyá
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
bit.0x8000 - Törzstag | 574 hsz       Online status #177926   2012.04.08 16:58 GMT+1 óra  
Idézet
Asylum :
Jajj ez a sok vonal ááh...tegye fel a kezét aki lát ebböl bármit is, mert én nem...


És így?
(Arra nem veszek mérget, hogy működik is, mivel csak ad hoc írtam át, meg mostanában nem is C++-oztam.)
Kód:
#pragma once

#include "Memory.h"

class Reference
{   public:
        unsigned short ReferenceValue = 0;
};

template <class T> class PTR
{   public:
        T *Base;

    public:
        inline PTR() : Base(new T()) { }
   
        inline PTR(const PTR &s) : Base(s.Base)
        {
            Base->ReferenceValue++;
        }
   
        inline ~PTR()
        {
            if (Base->ReferenceValue) Base->ReferenceValue--;
            else delete Base;
        }
   
        inline void operator=(PTR s)
        {
            if (Base)
            {   if (Base->ReferenceValue) Base->ReferenceValue--;
                else delete Base;
            }
            (Base = s.Base)->ReferenceValue++;
        }
   
        inline T *operator->()
        {
            return Base;
        }
   
        inline void operator<<(PTR s)
        {
            if (Base->ReferenceValue) Base->ReferenceValue--;
            else delete Base;
            *(Base = new T())  = *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)
            {   if (Base->ReferenceValue) Base->ReferenceValue--;
                else delete Base;
            }
            (Base = s)->ReferenceValue++;
        }
};

Ezt a hozzászólást bit.0x8000 módosította (2012.04.08 17:24 GMT+1 óra, ---)
   
Asylum - Törzstag | 5484 hsz       Online status #177925   2012.04.08 16:55 GMT+1 óra  
De nem annyit mint te wázegh Pl. minek kiirni hogy itt jönnek a konstruktorok, mikor ugyis mindenki látja, hogy konstruktor Meg ha egy-két soros fv van akkor aközé nem teszek vonalat, inkább a) inlineositom b) többet rakok egymás alá. És header fájlba se rakok vonalat Annyira jó ez a smiley

Olyat szoktam még hogy

Kód:
//===========================
// Rövid ismertetö a fvröl
//===========================
void fuggveny()
{
}

//===========================
// Rövid ismertetö a masik fvrol
//===========================
void fuggveny2()
{
}


De alapvetöen a pucér fájlokat szeretem, csak egy 75 ezer soros kódot már nem fogok végig baszkurálni (még regkiflivel sem).
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
versio - Tag | 673 hsz       Online status #177924   2012.04.08 16:53 GMT+1 óra  
Asylum: te is hasznalsz vonalat , akkor nemertem a dobbenetet
   
versio - Tag | 673 hsz       Online status #177923   2012.04.08 16:50 GMT+1 óra  
sirpalee: xd, a pointer osztaly durvan optimalizalt ,mivel minden valtozo meghivja ha tortenik vele valami, pl fuggveny parameter aradaskor, adatelem eleresnel, masolaskor stb
ez a kod 3 het munka eredmenye, es csak 30%-al lassabb mint a sima c, es ez adattombre is ervenyes, merd le a c# sebesseget es csodalkozz
   
Asylum - Törzstag | 5484 hsz       Online status #177921   2012.04.08 16:47 GMT+1 óra  


So far ennyi. Header fájlokba még szoktam doxygen kommentet.
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
sirpalee - Tag | 1282 hsz       Online status #177920   2012.04.08 16:46 GMT+1 óra  
versio : akkor ezért fordult olyan gyorsan a c# kódod, mert csak kommentből állt az egész

mondtam én, hogy van ott valami turpis-turpis
raytraceisten és übermedic
   
versio - Tag | 673 hsz       Online status #177919   2012.04.08 16:41 GMT+1 óra  
Asylum: nade te hasznalsz cpp filokat ahol definialod a fuggvenyeket, azt mutasd meg
   
Asylum - Törzstag | 5484 hsz       Online status #177917   2012.04.08 16:32 GMT+1 óra  
Mármint szép foszöld
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
Pretender - Törzstag | 2498 hsz       Online status #177916   2012.04.08 16:31 GMT+1 óra  
Fura, nekem változó. Ha úgy vagyok vele, hogy később nem fogom tudni, vagy nagyon egybefolyna, akkor használok kommentet, mert szép zöld.

   
Asylum - Törzstag | 5484 hsz       Online status #177915   2012.04.08 16:28 GMT+1 óra  
Hát valamivel jobb, de az én filozófiám szerint a kód lényege a kód és nem a komment, márpedig a nagybetü és a 2 km-es vonal eléggé megvezeti a szemet. És különbenis a meztelenkedés jó a kódban is

C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
versio - Tag | 673 hsz       Online status #177914   2012.04.08 16:22 GMT+1 óra  
persze mert igy szoktam meg, most 1 sor vagy szaz mindegy
ha bemasolod vc-be eleg jol atlathato a kod
persze elobb jelold ki az egeszet es nyomj ALT+F8-at, a tabulatorokat visszahozza
   
Asylum - Törzstag | 5484 hsz       Online status #177913   2012.04.08 16:18 GMT+1 óra  
Najó de itt egysoros deklarációkhoz meg fvekhez rakod oda. Nem is tudom hogy hivják ezt szépen...segédvonal? Vezérvonal?
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
versio - Tag | 673 hsz       Online status #177912   2012.04.08 16:14 GMT+1 óra  
azert ha egy osztaly tobb mint ezer sor, jol jonnek a vonalak
en attol tudod kifutni a vilagbol ha omlesztve van minden, plusz meg cpp file
   
Asylum - Törzstag | 5484 hsz       Online status #177910   2012.04.08 16:09 GMT+1 óra  
És van még munkád?
Az enyémet is szidják agyba föbe, ettöl sztem kirohannának a világbol
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
versio - Tag | 673 hsz       Online status #177909   2012.04.08 16:08 GMT+1 óra  
mindenkinek megvan a sajat kodolasi stilusa, az enyem ilyen
   
Asylum - Törzstag | 5484 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 | 673 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 | 673 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 | 673 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 | 673 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 | 5484 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 | 673 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?
   
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] [142]