C / C++ / MFC

if(sizeof(T)<=sizeof(T*)){

} else {

}

class Range{
        private:
                int mStart,mSize,myID;
        public:
                Range(int aStart,int aSize):mStart(aStart),mSize(aSize){}
                Range(Range& r):mStart(r.mStart),mSize(r.mSize){}
                Range(const Range& r):mStart(r.mStart),mSize(r.mSize){} //needed to return 'by value'
                bool operator () (int x){
                        return x>=0? (x<mSize || mSize==0):(-x <= mSize || mSize==0);
                }
                int operator [] ( int x ) {
                        if(!operator()(x)) throw std::range_error("Range throwing exception; invalid indice number.");
                        return x + mStart;
                }
                int Size( ){ return mSize; }
                int Size( int aSize ){ return mSize = aSize; }
                int Start( ) { return mStart; }
                int Start( int aStart ){ return mStart = aStart; }
};

Range All( int size = -1 ) {
        if(size==-1) size = arraySize;
        const Range ret(0,size);
        return ret;
}

T& Add(const T& nElement, int indice = -1){
        Allocate();
        ++arraySize;
        Range ran = All();
        indice = ran[indice];
        if ( indice < 0 ) indice = arraySize + indice;
        if(sizeof(T)<=sizeof(T*)){
                if(static_cast<unsigned int>(indice+1)!=arraySize) memcpy(&(((T*)tElements)[indice+1]),&(((T*)tElements)[indice]),sizeof(T)*(arraySize-indice-1));
                memcpy(&(((T*)tElements)[indice]),&nElement,sizeof(T));
                return (((T*)tElements)[indice]);
        } else {
                memcpy( &(tElements[indice+1]),&(tElements[indice]),sizeof(T*)*(arraySize-indice));
                if(construct) return *(tElements[indice] = new T(nElement));
                else{
                        T* nPtr = (T*)new char[sizeof(T)];
                        memcpy(nPtr,&nElement,sizeof(T));
                        return *(tElements[indice] = nPtr);
                }
        }
}

vString& vString::Insert(char* str,Range& ran){
        if(!str) throw std::runtime_error("vString::Insert(const char*,Range&) - Invalid first argument.");
        int end = (ran.Size())?ran.Size():strlen(str)+1;
        Allocate( end );
        if(arraySize == 0 ) // first string...
                memcpy(&(((char*)tElements)[0]),str,arraySize = end);
        else memcpy()
        for(int i=0;i<end;i++,str++) Vector<char>::Add(*str,ran.Start());
        arraySize--;
        return *this;
}
vString& vString::Insert(const char* str,Range& ran){
        if(!str) throw std::runtime_error("vString::Insert(const char*,Range&) - Invalid first argument.");
        int end = (ran.Size())?ran.Size():strlen(str)+1;
        Allocate( end );
        if(arraySize == 0 ) // first string...
                memcpy(&(((char*)tElements)[0]),str,arraySize = end);
        else{
                Range& all = All();
                int indice = ran.Start();
                indice = all[indice];
                if(indice<0)indice+=arraySize;
                if(indice<0)indice=0;
                memcpy(&(((char*)tElements)[indice+end-1]),&(((char*)tElements)[indice]),end-1)
        }
        arraySize--;
        return *this;
}

Tyler Elric wrote:

Is this what your'e referring to as "Move semantics" ?

__LINE__

__FILE__ 

Dump(__FILE__,__LINE__,"Still Alive")

maheen zahra wrote:

please send me topics

maheen zahra wrote:

<layer> or data

maheen zahra wrote:

that are related to loops&functions

while(stillstupid  || stilllazy)
{
buybook(*dollars);
readbook(*brain);
understand(*hardwork);
)

makemoney(*moredollars);