//
//  scalar polynome.c
//  dynamic array class
//
//  Created by Servant of Horror on 03.03.14.
//  Copyright (c) 2014 Servant of Horror. All rights reserved.
//

#include <iostream>
//#include <conio.h>
#include <stdio.h>

using namespace std;

class CString { // описание класса “точка”
public:
    int x; // координаты точки
    ~CString() { cout << x << endl; } // деструктор
    void Set( int newX=0) { x=newX; } // установка значений
    CString( int newX=0 ) { Set(newX); }    // конструктор
    
    CString operator[] (int i) const { // перегружаем []
        return ((CString*)this)[i];
    }
    
    CString& operator[] (int i)  { // перегружаем []
        return ((CString*)this)[i];
    }
};


CString * CreateStArray( int N ) // инициализируем создание
{
    CString * cChar;
    cChar = new CString [N];
    return cChar;
}



void display (CString Css[]){
    int i;
    int a = (sizeof(&Css)/sizeof(&Css[0]));
    for (i=0;i<a;i++) {printf ("%c", Css[i].x); if (i%7==0) printf ("\n");}
    printf ("\n");
}

CString * Insert (CString Cs[], char k)// вставляем элемент в начало массива
{
    int i,p;
    p=sizeof(&Cs);
    CString * Css =  CreateStArray((sizeof&Cs)/(sizeof(&Cs[0]))+1);
    for(i=0;i<p;i++){
        Css[i+1]=Cs[i];
    }    // уточнить по принципу работы , нужно ли сдвигать
    Css[0].Set(k);
    delete [] Cs;
    return Css;
}

CString * Remove(CString Cs[], char k){// уничтожаем элемент
    int i=0;
    int ii=0;
    int iii=0;
    int p = (sizeof(&Cs)/sizeof(&Cs[0]));
    CString * Css = CreateStArray(p);
    if (Css==NULL) printf ("Memory Error"); return Cs;
    for (;i<p;){
        if (Cs[i].x!=k) Css[ii]=Cs[i]; i++, ii++;
        if (Cs[i].x==k) iii++; i++;
    }
    delete [] Cs;
    CString * Csss = CreateStArray(p-iii);
    if (Csss==NULL) printf ("Memory error. Massive with zeroed endvalues will be returned"); return Css;
    for (i=0;i<(p-iii);i++) Csss[i]=Css[i];
    delete [] Css;
    return Csss;
}

CString * MergeArrays (CString foo[], CString bar[])// oбъединение массивов
{
    int i=0;
    int p = (sizeof(&foo)/sizeof(&foo[0]));
    int u = (sizeof(&bar)/sizeof(&foo[0]));
    int k=(p+u);
    CString * Cs = CreateStArray(k);
    if( Cs!=NULL ) {
        for( int i=0 ; i<p ; i++ ) {
            Cs[i]=bar[i]; // инициализация массива
        }
        for( int i=0 ; i<u ; i++ ) {
            Cs[i+p]=bar[i]; // инициализация массива
        }
        delete [] foo;
        delete [] bar;
    }
    else {
        printf ("memory allcation error");
        Cs[i].Set(0);
    }
    return Cs;
}

class Poly : public CString {
    public int k0, k1, k2, k3;
    Poly (CString x) {k1 = x[1], k2=x[2], k3=x[3], k0=x[0]};
    Poly~ ();
    operator& + (Poly x, Poly y){
        Poly z;
        z.k0=x.k0+y.k0;
        z.k1=x.k1+y.k1;
        z.k2=x.k2+y.k2;
        z.k3=x.k3+y.k3;
        return z;
    }
    
    operator& - (Poly x, Poly y){
        Poly z;
        z.k0-x.k0+y.k0;
        z.k1-x.k1+y.k1;
        z.k2-x.k2+y.k2;
        z.k3-x.k3+y.k3;
        return z;
    }
    
    operator& += (Poly x, Poly y){
        x.k0=x.k0+y.k0;
        x.k1=x.k1+y.k1;
        x.k2=x.k2+y.k2;
        x.k3=x.k3+y.k3;
        return x;
    }
    
    operator& -= (Poly x, Poly y){
        x.k0=x.k0-y.k0;
        x.k1=x.k1-y.k1;
        x.k2=x.k2-y.k2;
        x.k3=x.k3-y.k3;
        return x;
    }
    int operator& * (Poly x, Poly y){
        int z;
        z=(x.k0*y.k0+x.k1*y.k1+x.k2*y.k2);
        return z;
    }
    operator& *= (Poly x, Poly y){
        
        x.k0=(x.k0*y.k0+x.k1*y.k1+x.k2*y.k2);
        return x;
    }
};
float scalar (Poly x, Poly y){
    return (x.k0*y.k0+x.k1*y.k1+x.k2*y.k2)
}