Меня пригласили в американскую компанию в штате мэриленд

template <class Type,typename IndexType=int, class RefType=Type> class TBaseArray:public TNamedType,public TStremable{
protected:
    static const IndexType NotInList=-1;    
    IndexType FCount;
    IndexType FCapacity;    
    IndexType FGrowStep;
        Type* Data;
 
    inline void Grow(IndexType RequiredSize){       
        if (!GrowStep) EResizeError(TypeName," can not resize, grow step is 0.");
        int a=GrowStep-RequiredSize%GrowStep;
        Capacity=RequiredSize+a;
    };
 
    
    inline void CheckBounds(IndexType Index){
           if (Index<0||Index>=Count) throw ERangeError(FTypeName,Index);    
    }
    void CopyData(Type* Dst){for(IndexType i=0;i<Count;i++)Dst[i]=Data[i];};
    void ShiftToHead(IndexType Index){for(IndexType i=Index;i<Count-1;i++)Data[i]=Data[i+1];};
    void ShiftToTail(IndexType Index){for(IndexType i=Index;i<Count-1;i++)Data[i+1]=Data[i];};
    TBaseArray(IndexType aGrowStep=16,char* aTypeName=nullptr):TNamedType(aTypeName),Data(nullptr),FCount(0),FCapacity(0){      
        GrowStep=aGrowStep;
    };  
public: 
    inline IndexType GetCount()const{return FCount;} ;
    inline IndexType GetCapacity()const{return FCapacity;};
    inline IndexType GetGrowStep()const{return FGrowStep;};
    inline void SetGrowStep(IndexType NewGrowStep){
           if (NewGrowStep<0)
#ifdef __DEBUG__ 
               throw EArrayError(TypeName,"Grow step can not be negative.");
#else
               NewGrowStep=0;
#endif
           FGrowStep = NewGrowStep;
    }
    inline void SetCapacity(int NewCapacity){
           if (NewCapacity<0)NewCapacity=0;
           if (NewCapacity==Capacity) return;
           if (NewCapacity<Count)FCount=NewCapacity;    
           Type* NewData;
           try{
              NewData=NewCapacity?new Type[NewCapacity]:nullptr;       
           } catch(...){
               throw EResizeError(TypeName," memory allocation failed");
           }
           if (Data){
               CopyData(NewData);          
               delete [] Data;
           };
           Data=NewData;
           FCapacity=NewCapacity;
    };
    inline void SetCount(IndexType NewCount){
           if (Capacity<NewCount)Grow(NewCount);   
           FCount=NewCount;
    } ;
        
    inline Type GetItem(IndexType Index)const{return (*this)[Index];};
        inline void SetItem(IndexType Index,const RefType Type ){(*this)[Index]=Type;};
    inline IndexType Add(const RefType NewValue){
        Count++;
        Items[Count-1]=NewValue;
        return Count-1;
    }
 
    inline void Insert(IndexType Index,const RefType NewValue){
#ifdef __DEBUG__
    CheckBounds(Index);
#endif
        Count++;
        ShiftToTail(Index);     
        Data[Index]=NewValue;
    };
    inline void Delete(IndexType Index, bool KeepOrder=true){
#ifdef __DEBUG__
    CheckBounds(Index);
#endif
            if (KeepOrder)ShiftToHead(Index);
            else Data[Index]=Data[Index-1];
            FCount--;       
    };
    IndexType Remove(const Type Needle,bool KeepOrder=true){
        IndexType n=IndexOf(Needle); 
        if (NotInList!=n) Delete(n,KeepOrder);
        return n;
    };
    IndexType IndexOf(const RefType Needle)const{
        for(IndexType i=0;i<Count;i++){
            if (Data[i]==Needle)return i;
        };
        return NotInList;
    };
    inline void Clear(){Count=0;};
    inline Type& operator[](IndexType Index){ 
#ifdef __DEBUG__
        CheckBounds(Index);    
#endif
        return Data[Index];
    };
    virtual void SaveToStream(TStream* Stream){
            Stream->Write(&FCount,sizeof(IndexType));
            if (FCount)Stream->Write(Data,FCount*sizeof(Type));
    } 
    virtual void LoadFromStream(TStream* Stream){
            Clear();
            IndexType NewCount;
            Stream->Read(&NewCount,sizeof(NewCount));
            Count=NewCount;            
            if (FCount)Stream->Read(Data,FCount*sizeof(Type));
    } 
 
    ~TBaseArray(){
          if (Data) delete [] Data;
    }
    __declspec(property(get=GetItem,put=SetItem)) Type Items[];  
    __declspec(property(get=GetCount,put=SetCount)) IndexType Count;  
        __declspec(property(get=GetCapacity,put=SetCapacity)) IndexType Capacity;  
        __declspec(property(get=GetGrowStep,put=SetGrowStep)) IndexType GrowStep;  
};
 
template <class Type=void,typename IndexType=int>
class TArray:public TBaseArray<Type,IndexType,Type&>
{
public: 
    TArray(IndexType aGrowStep=16):TBaseArray(aGrowStep=16,"TArray"){};
    inline Type* GetDataPtr(){return Data;};
    inline IndexType GetDataSize(){return Count*sizeof(Type);};
    __declspec(property(get=GetDataPtr)) Type* DataPtr;
    __declspec(property(get=GetDataSize)) IndexType DataSize;
};
    
template <class Type=void,typename IndexType=int>
class TList:public TBaseArray<Type*,IndexType,Type*>
{
protected:
    void CopyData(Type** Src){memcpy(Data,Src,Count*sizeof(Type*));};
    void ShiftToHead(IndexType Index){memmove(Data+Index,Data+Index+1,(Count-Index-1)*sizeof(Type*));};
    void ShiftToTail(IndexType Index){memmove(Data+Index+1,Data+Index,(Count-Index-1)*sizeof(Type*));};
    TList(IndexType aGrowStep, char* aTypeName):TBaseArray(aGrowStep,"aTypeName"){};
public: 
    TList(IndexType aGrowStep=16):TBaseArray(aGrowStep,"TList"){};
};
 
template <class Type=void,typename IndexType=int>
class TUniqueList:public TList<Type,IndexType>
{
protected: 
    TUniqueList(IndexType aGrowStep=16,char* aTypeName=nullptr):TList(IndexType aGrowStep=16,char* aTypeName=nullptr){};
public: 
    TUniqueList(IndexType aGrowStep=16):TList(aGrowStep,"TUniqueList"){};
    inline IndexType Add(const Type* NewValue){
           int n=IndexOf(NewValue);
           if (n!=NotInList) return n;
           return TList::Add(NewValue);
    };
};
 
template <class Type,class OwnerType,typename IndexType=int >
class TOweList:public TList<Type,IndexType>
{
private: 
    OwnerType *Owner;
public: 
    TOweList(OwnerType* aOwner, IndexType aGrowStep=16):TList(aGrowStep,"TOweList"),Owner(aOwner){};
    void Clear(){
        for(int i=0;i<Count;i++) if (Data[i]) delete Data[i];
        TList::Clear();
    };
    virtual void LoadFromStream(TStream* Stream){
            Clear();
            IndexType NewCount;
            Stream->Read(&NewCount, sizeof(NewCount));
            Count=NewCount;
            for(int i=0;i<Count;i++){
                Data[i]=new Type(Owner); 
                Data[i]->LoadFromStream(Stream);
            };  
    }
    virtual void SaveToStream(TStream* Stream){    
            Stream->Write(&FCount, sizeof(FCount));
            for(int i=0;i<Count;i++){           
                Data[i]->SaveToStream(Stream);
            };  
    }
};

class StreamableString : public AnsiString {
public:
 
    StreamableString() : AnsiString() {
    };
 
    StreamableString(char *c) : AnsiString(c) {
    };
 
    StreamableString(AnsiString S) : AnsiString(S) {
    };
 
    void LoadFromStream(TStream* Stream) {
        int Cnt;
        Stream->Read(&Cnt, sizeof(Cnt));
        SetLength(Cnt);
        Stream->Read(c_str(), Cnt);
    };
 
    void SaveToStream(TStream* Stream) {
        int Cnt = Length();
        Stream->Write(&Cnt, sizeof(Cnt));
        Stream->Write(c_str(), Cnt);
    };
};

int a, b, c;
    a = b = 0;
    c = 10;
    (1 ? a : b) = c;
    cout << a << endl << b << endl << c << endl;

int a, b, c, d;
    cin >> d;
    a = b = 0;
    c = 10;
    (d ? a : b) = c;
    cout << a << endl << b << endl << c << endl;