eure meinung: array-klasse

mojo?

Move of Joint Objects

rüdiger

http://www.cuj.com/documents/s=8246/cujcexp2102alexandr/

operator void

Ein ziemlicher Brocken für eine statische Array-Klasse jedenfalls Was mir beim Drüberfliegen nur aufgefallen ist: "char value[]" sieht nicht sehr portabel aus und dein künstliches Lifetime-Management (construct etc.) scheint Exceptions aus Konstruktoren nicht standzuhalten. Hast du dir std::unitialized_fill mal angesehen?

Shade Of Mine

operator void schrieb:

Ein ziemlicher Brocken für eine statische Array-Klasse jedenfalls

naja, das ding kann ja auch was

boosts array ist auch nicht viel kleiner (nur gibts dort halt kein copy-policy)

Was mir beim Drüberfliegen nur aufgefallen ist: "char value[]" sieht nicht sehr portabel aus

wieso denn nicht?
bitte erklaeren.

und dein künstliches Lifetime-Management (construct etc.) scheint Exceptions aus Konstruktoren nicht standzuhalten.

danke habe ich jetzt verbessert.

Hast du dir std::unitialized_fill mal angesehen?

ja, aber wo sollte ich das verwenden koennen?

volkard

Copy::destructiveInit< (otherSize < Size ? otherSize : Size), value_type >(begin(), other.begin());

ist gar häßlich.

Shade Of Mine

volkard schrieb:

Copy::destructiveInit< (otherSize < Size ? otherSize : Size), value_type >(begin(), other.begin());

ist gar häßlich.

da stimm ich dir zu, doch leider weiss ich nicht, wie man das schoener machen kann.

uU ein makro my_min() definieren, aber das macht die ganze sache auch nicht schoener.

std::min() ist ja ne inline funktion - da verliere ich damit die compile time konstante

ich bin sicher, dass du eine bessere idee hast - ich wuerde mich freuen diese zu erfahren. danke

operator void

Shade Of Mine schrieb:

operator void schrieb:

Was mir beim Drüberfliegen nur aufgefallen ist: "char value[]" sieht nicht sehr portabel aus

wieso denn nicht?
bitte erklaeren.

Wegen allerlei seltsamen Alignmentproblemen. Zumindest habe ich das mal als Begründung gegen solche Techniken auf einer Internetseite gelesen, Erfahrung habe ich da keine.

Shade Of Mine schrieb:

Hast du dir std::unitialized_fill mal angesehen?

ja, aber wo sollte ich das verwenden koennen?

Anstelle des zweiten constructs, hätte ich gedacht.

volkard

#ifndef ANGST_VOR_MAKROS
#define MIN(a,b) Min<a,b>::value
#endif

Shade Of Mine

volkard schrieb:

#ifndef ANGST_VOR_MAKROS
#define MIN(a,b) Min<a,b>::value
#endif

*patsch* entweder bin ich blind und bloed, dass ich auf sowas nie komme, oder du bist n genie.

danke!!

@operator void:
kannst du auch was kongretes zum alignment problem posten?

so wie ich unitialized_fill verstanden habe, wuerde es in meinem Fall
T(T()); aufrufen, oder?
denn ich will nur den default ctor aufrufen, also uebergebe ich unitialized_fill einfach nur T() und unitialized_fill ruft dann jeden ctor mit T() als param auf.

wenn das nicht so ist, bitte aufklaeren.

#define ANGST_VOR_MAKROS

operator void

Shade Of Mine schrieb:

@operator void:
kannst du auch was kongretes zum alignment problem posten?

http://www.gotw.ca/gotw/028.htm

Daher hatte ich meine Bedenken wohl. Mir ist vorhin nur nicht eingefallen, wo ich das aufgeschnappt hatte.

Shade Of Mine schrieb:

so wie ich unitialized_fill verstanden habe, wuerde es in meinem Fall
T(T()); aufrufen, oder?
denn ich will nur den default ctor aufrufen, also uebergebe ich unitialized_fill einfach nur T() und unitialized_fill ruft dann jeden ctor mit T() als param auf.

So wäre es in deiner ersten construct-Funktion. Mit unitialized_fill kannst du aber, so wie ich es wiederum verstanden habe, deine zweite construct-Funktion ersetzen (und sparst damit immerhin die Hälfte des Exception-Ärgers).

volkard

die array-klasse hat ein massives simplizitätsdefizit und bekommt von mir nur die note 3.

Shade Of Mine

operator void schrieb:

Shade Of Mine schrieb:

@operator void:
kannst du auch was kongretes zum alignment problem posten?

http://www.gotw.ca/gotw/028.htm

danke, aber so schlimm sehe ich das nicht.
schliesslich gibt es keine andere moeglichkeit mein vorhaben anders zu implementieren.

in Sutters Beispiel wird char[] ja auch missbraucht.

So wäre es in deiner ersten construct-Funktion. Mit unitialized_fill kannst du aber, so wie ich es wiederum verstanden habe, deine zweite construct-Funktion ersetzen (und sparst damit immerhin die Hälfte des Exception-Ärgers).

hab mir gerade uninitialized_fill angesehen:

es ist so implementiert: (vereinfacht)

template <class ForwardIter, class Type>
void uninitialized_fill(ForwardIter first, ForwardIter last, const Tp& x)
{
  ForwardIter cur = first;
  for(; cur != last; ++cur)
  {
    new (&*cur) Type(x);
  }
}

es wird also nicht der Default Ctor aufgerufen, sondern der copy ctor (fuer x==T())

das macht die sache nicht unbedingt langsamer, aber es ist nicht das was ich will. es soll ja der default ctor aufgerufen werden

operator void

Ich glaube, wir reden aneinander vorbei

Jo, die Version mit dem Defaultkonstruktor musst du dir selbst schreiben, aber ich wollte ja auch nur folgende Funktion aus deiner array.hpp durch uninitialized_fill ersetzen:

template<typename TRG, typename SRC>
static void construct(void* value, SRC src, std::size_t size)
{
    char* p=static_cast<char*>(value);
    for(std::size_t i=0; i<size; ++i)
    {
        new(p+(i*sizeof(TRG)))TRG(*src);
        ++src;
    }
}

Shade Of Mine

@operator void:
aso, jetzt kapier ich.

ne, das geht nicht. denn bei uninitialized_fill kann man nur 1 wert angeben, ich moechte aber ein ganzes array verwenden.

also brauch ich unitialized_copy
danke! dank dir bin ich auf uninitalized_copy gestossen!!

operator void

Ups. Hab deine Funktion irgendwie falsch gelesen *patsch* Naja, jetzt ist ja alles klar

Shade Of Mine

volkard schrieb:

die array-klasse hat ein massives simplizitätsdefizit und bekommt von mir nur die note 3.

dabei hat keine funktion mehr als 6 zeilen

darf man mal deine static array klasse sehen? vielleicht kann ich mir da n paar tricks abschauen wie man das einfacher machen kann?

denn ich bin zu unfaehig das ding zu vereinfachen

lies einfach diese gotw artikel nicht...dann schreibst du auch nicht so freakige klassen

volkard

Shade Of Mine schrieb:

darf man mal deine static array klasse sehen? vielleicht kann ich mir da n paar tricks abschauen wie man das einfacher machen kann?

hab keine. aber ich les mir den code mal durch und meckere ein wenig rum.

aber ich würde dran denken, den rohen speicher in ne klasse zu packen. sagen wir mal, sie hat platz für Size objekte vom typ Type, aber konstuiert und destruiert mal gar nix. macht aber arraygrenzencheck und adressarithmetik.

die objekte sollen andersrum zerstört werden, als sie angelegt wurden.

ich kann nicht nachvollziehen, warum construct nen void* kriegen tut.

ClassCopy kommt mir sehr groß vor. werden wirklich alle diese funktionen gebraucht?

template<typename otherType> Array(otherType const* value, size_type size)

muß weg wegen is nicht. wenn du auf stl abfährst, dann haste die version mit zwei iteratoren.

assert(size>Size);
std::size_t length=std::min(size,Size);

erscheint mir wirr. ich denke, nach assert(size>Size) ist die zweite zeile mindersinnvoll. ich schließe auf programmiererüberlastung weils nicht einfach genug ist.

Copy::construct<value_type>(this->value, value, length);
Copy::construct<value_type>(this->value+(length*sizeof(value_type)), Size-length);

überlastet mich. ich lese immer nur construct. kein wunder, daß ich nicht kapiere, daß die obere zeile ein copyconstruct und die untere ein defaultconstruct macht.

std::size_t length=std::min(end-beg,Size);

warum denke ich an const?

Copy::destructiveCopy< (otherSize < Size ? otherSize : Size) >(begin(), other.begin());

oh, du nimmst begin() als parameter für Copy-sachen. warum? um zu postulieren, daß der iterator ein Type* ist? oder warum nicht bei

Copy::construct<value_type>(this->value+(length*sizeof(value_type)), Size-length);

?

wozu assign?

wozu at?

wozu data?

*static_cast<TRG*>(p+(i*sizeof(TRG)))=src;

und

return *(((value_type*)value)+Size-1);

wundert mich so vom stilbruch her.

und mit

return ((value_type*)value);

machte komische klammern wie in c.

reverse_iterator rbegin()
{
    return reverse_iterator(begin());
}

kapier ich net.

wozu empty? ohne push und pop kaum nutzbar.

template<typename T1, std::size_t Size1, class Copy1, typename T2, std::size_t Size2, class Copy2>
    bool operator==(Array<T1, Size1, Copy1> const& a, Array<T2, Size2, Copy2> const& b)
    {
        if(Size1!=Size2) return false;

        return Copy::equal<Size1>(a.begin(), b.begin());
    }

wolltest du da nicht zur compilezeit bei ungleichen größen false berechnen und nur bei gleichheit der größen zur laufzeit ne schleife benutzen? könnt ja sonst nen nutzlosen funktionsaufruf erzeugen.

irgendwie gefällt mir

template<typename T>
       static void construct(void* value, std::size_t size)
        {
            std::size_t i=0;
            try
            {
                char* p=static_cast<char*>(value);
                for(; i<size; ++i)
                {
                    new(p+(i*sizeof(T)))T();
                }
            }
            catch(...)
            {
                destruct<T>(value,i);
                throw;
            }
        }

nicht.

template<typename T>
        static void construct(T* begin,T* end)
        {
            T* pos=begin;
            try
            {
                while(pos!=end)
                {
                   new(pos)T;
                   ++pos;
                }
            }
            catch(...)
            {
                do
                {
                   --pos;
                   pos->~T();
                }while(pos!=begin);
                throw;
            }
        }

oder vielleicht

template<typename T,std::size_t SIZE>
        static void construct(T* data)
        {
            std::size_t i=0;
            try
            {
                while(i!=SIZE)
                {
                   new(data+i)T;
                   ++i;
                }
            }
            catch(...)
            {
                do
                {
                   --i;
                   (data+i)->~T();
                }while(i!=0);
                throw;
            }
        }