// Эти классы реализовывать заново не нужно
struct ICloneable;

// Поле data_ типа T в классе ValueHolder
// открыто, к нему можно обращаться
template <typename T>
struct ValueHolder;

// Это класс, который вам нужно реализовать
class Any
{
    // В классе Any должен быть конструктор,
    // который можно вызвать без параметров,
    // чтобы работал следующий код:
    //    Any empty; // empty ничего не хранит

    // В классе Any должен быть шаблонный
    // конструктор от одного параметра, чтобы
    // можно было создавать объекты типа Any,
    // например, следующим образом:
    //    Any i(10); // i хранит значение 10

    // Не забудьте про деструктор. Все выделенные
    // ресурсы нужно освободить.

    // В классе Any также должен быть конструктор
    // копирования (вам поможет метод clone
    // интерфейса ICloneable)

    // В классе должен быть оператор присваивания и/или
    // шаблонный оператор присваивания, чтобы работал
    // следующий код:
    //    Any copy(i); // copy хранит 10, как и i
    //    empty = copy; // empty хранит 10, как и copy
    //    empty = 0; // а теперь empty хранит 0

    // Ну и наконец, мы хотим уметь получать хранимое
    // значение, для этого определите в классе Any
    // шаблонный метод cast, который возвращает
    // указатель на хранимое значение, или нулевой
    // указатель в случае несоответствия типов или
    // если объект Any ничего не хранит:
    //    int *iptr = i.cast<int>(); // *iptr == 10
    //    char *cptr = i.cast<char>(); // cptr == 0,
    //        // потому что i хранит int, а не char
    //    Any empty2;
    //    int *p = empty2.cast<int>(); // p == 0
    // При реализации используйте dynamic_cast,
    // который мы уже обсуждали ранее.
};

#include <iostream>

using namespace std;

struct ICloneable
{
    virtual ICloneable* clone() const = 0;
    virtual ~ICloneable() { }
};

template <typename T>
struct ValueHolder : ICloneable {
    ValueHolder(const T& data): data_(data){}
    T data_;
    ValueHolder * clone() const {
        return new ValueHolder(*this);
    }
};

class Any
{
    ICloneable * ptr;

public:
    Any() : ptr(0) { }

    template <class value_t>
    Any(const value_t& v_) : ptr(new ValueHolder<value_t>(v_)) { }

    Any(Any const & other) : ptr(other.ptr ? other.ptr->clone() : 0) {}

    Any& operator=(Any const & other)
    {
        if(this->ptr)
            delete this->ptr;
        this->ptr = NULL;
        if (other.ptr)
        {
            this->ptr=other.ptr->clone();
        }
        return *this;
    }
    template <class A>
    Any& operator=(A const& other)
    {
        if(this->ptr)
            delete this->ptr;
        this->ptr = NULL;
        if (other)
        {
            this->ptr=new ValueHolder<A>(other);
        }
        return *this;
    }

    ~Any() { delete this->ptr; }
    template <class T>
    T* cast()
    {
        if (dynamic_cast<ValueHolder<T>*>(this->ptr))
        {
            return (T*)dynamic_cast<ValueHolder<T>*>(this->ptr);
        }
        else
        {
            return 0;
        }
    }
};


int main()
{

    Any empty;
    Any i(10);
    cout << "[1] i=" << i.cast<int>() << endl;
    Any copy(i);
    cout << "[2] copy=" << copy.cast<int>() << endl;
    empty = copy;
    cout << "[3] empty=" << empty.cast<int>() << endl;
    empty = 0;
    cout << "[4] empty=" << empty.cast<int>() << endl;
    int *iptr = i.cast<int>();
    cout << "[5] *iptr=" << iptr << endl;
    char *cptr = i.cast<char>();
    cout << "[6] *cptr=" << cptr << endl;
    Any empty2;
    int *p = empty2.cast<int>();
    cout << "[7] *p=" << p << endl;
    Any a = 20;
    cout << "[8] a=" << a.cast<int>() << endl;
    a=0;
    cout << "[9] a=" << a.cast<int>() << endl;
    a='w';
    cout << "[10] a=" << a.cast<char>() << endl;
    return 0;
}

Array<int> ints(2, 0);
ints[0] = 10;
ints[1] = 20;
flatten(ints, std::cout); // выводит на экран строку "10 20"
Array< Array<int> > array_of_ints(2, ints);
flatten(array_of_ints, std::cout); // выводит на экран строку "10 20 10 20"
Array<double> doubles(10, 0.0);
flatten(doubles, std::cout); // работать должно не только для типа int

#include <iostream>


// Весь вывод должен осущствляться в поток out,
// переданный в качестве параметра.
//
// Можно заводить любые вспомогаетльные функции,
// структуры или даже изменять сигнатуру flatten,
// но при этом все примеры вызова из задания должны
// компилироваться и работать.

template <typename T>
void flatten(const Array<T>& array, std::ostream& out)
{ }

template <typename T>
  void flatten(const Array<T>& array, std::ostream& out)
  {
      if (typeid(Array<int>)==typeid(T) || typeid(Array<double>)==typeid(T)){
          // тут наверное надо рекурсивно вызывать flatten(array[i], out)
          // но так не выходит
      } else {
      for (int i=0; i<array.size(); ++i)
          out << array[i] << " ";
      }
  }

#include <cstddef>

template <typename T>
class Array
{
    // Список операций:
    //
    // Array(size_t size, const T& value = T())
    //   конструктор класса, который создает
    //   Array размера size, заполненный значениями
    //   value типа T. Считайте что у типа T есть
    //   конструктор, который можно вызвать без
    //   без параметров, либо он ему не нужен.
    //
    // Array()
    //   конструктор класса, который можно вызвать
    //   без параметров. Должен создавать пустой
    //   Array.
    //
    // Array(const Array &)
    //   конструктор копирования, который создает
    //   копию параметра. Для типа T оператор
    //   присвивания не определен.
    //
    // ~Array()
    //   деструктор, если он вам необходим.
    //
    // Array& operator=(...)
    //   оператор присваивания.
    //
    // size_t size() const
    //   возвращает размер массива (количество
    //                              элемнтов).
    //
    // T& operator[](size_t)
    // const T& operator[](size_t) const
    //   две версии оператора доступа по индексу.
};

template <typename T>
class Array
{
public:
    explicit Array(size_t size = 0, const T& value = T())
        :size_(size), data(new T[size])
    {
        for (int i=0; i<size; i++)
            data[i] = value;
    }
    //Array():size_(0), data(new T[0]) {}

    Array(const Array &arrayToCopy)
    {
        size_ = arrayToCopy.size();
        data = static_cast<T*>(operator new[] (size_ * sizeof(T)));
        for ( int i = 0; i < size_; ++i)
            data[i] = arrayToCopy[i];
    }
    ~Array()
    {
        for (int i = 0; i < size_; i++)
          {
              data[i].~T();
          }
        operator delete[](data);
    }

    Array& operator=(const Array & right)
    {
        size_=right.size();
        char * buff = new char[size_ * sizeof(T)];
        data = new (buff) T[size_];
        for (int i=0; i< size_; ++i)
            data[i]=right[i];
        return *this;
    }
    size_t size() const
    {
        return size_;
    }
    T& operator[](size_t i)
    {
        return data[i];
    }
    const T& operator[](size_t i) const
    {
        return data[i];
    }
private:
    size_t size_;
    T * data;
};

struct Rational
{
    Rational(int numerator = 0, int denominator = 1);

    void add(Rational rational);
    void sub(Rational rational);
    void mul(Rational rational);
    void div(Rational rational);

    void neg();
    void inv();
    double to_double() const;

private:
    int numerator_;
    unsigned denominator_;
};

Rational& operator+=(Rational rational)
    {
        return (rational.add(*this));
    };
    Rational& operator-=(Rational rational)
    {
        return (rational.sub(*this));
    };
    Rational& operator*=(Rational rational)
    {
        return (rational.mul(*this));
    };
    Rational& operator/=(Rational rational)
    {
        return (rational.div(*this));
    };

    Rational operator-()
    {
        this->sub();
        return *this;
    };
    Rational operator+()
    {
        this->add();
        return *this;
    };

#include <cassert>
#include <string>
#include <cmath>

struct Transformer;
struct Number;
struct BinaryOperation;
struct FunctionCall;
struct Variable;

struct Expression
{
    virtual ~Expression() { }
    virtual double evaluate() const = 0;
    virtual Expression *transform(Transformer *tr) const = 0;
};

struct Transformer
{
    virtual ~Transformer() { }
    virtual Expression *transformNumber(Number const *) = 0;
    virtual Expression *transformBinaryOperation(BinaryOperation const *) = 0;
    virtual Expression *transformFunctionCall(FunctionCall const *) = 0;
    virtual Expression *transformVariable(Variable const *) = 0;
};

struct Number : Expression
{
    Number(double value);
    double value() const;
    double evaluate() const;
    Expression *transform(Transformer *tr) const;

private:
    double value_;
};

struct BinaryOperation : Expression
{
    enum {
        PLUS = '+',
        MINUS = '-',
        DIV = '/',
        MUL = '*'
    };
    BinaryOperation(Expression const *left, int op, Expression const *right);
    ~BinaryOperation();
    double evaluate() const;
    Expression *transform(Transformer *tr) const;
    Expression const *left() const;
    Expression const *right() const;
    int operation() const;

private:
    Expression const *left_;
    Expression const *right_;
    int op_;
};

struct FunctionCall : Expression
{
    FunctionCall(std::string const &name, Expression const *arg);
    ~FunctionCall();
    double evaluate() const;
    Expression *transform(Transformer *tr) const;
    std::string const &name() const;
    Expression const *arg() const;

private:
    std::string const name_;
    Expression const *arg_;
};

struct Variable : Expression
{
    Variable(std::string const name);
    std::string const & name() const;
    double evaluate() const;
    Expression *transform(Transformer *tr) const;

private:
    std::string const name_;
};


/**
 * реализйте все необходимые методы
 * если считаете нужным, то можете
 * заводить любые вспомогетльные
 * методы
 */
struct FoldConstants : Transformer
{
    Expression *transformNumber(Number const *number)
    { }

    Expression *transformBinaryOperation(BinaryOperation const *binop)
    { }

    Expression *transformFunctionCall(FunctionCall const *fcall)
    { }

    Expression *transformVariable(Variable const *var)
    {  }
};

struct FoldConstants : Transformer
{
    Expression *transformNumber(Number const *number)
    {
        return new Number(number->value());
    }
    Expression *transformBinaryOperation(BinaryOperation const *binop)
    {
        Expression * a;
        Expression * b;
        if (dynamic_cast<Number*>(binop->left()->transform(this)))
            {a = binop->left()->transform(this);}
        else
            {a = (Number*)(binop->left()->transform(this));}
        if (dynamic_cast<Number*>(binop->right()->transform(this)))
            {b = binop->right()->transform(this);}
        else
            {b = (Number*)(binop->right()->transform(this));}

        BinaryOperation * c = new BinaryOperation(a, binop->operation(), b);
        return new Number(c->evaluate());
        delete c;
    }
    Expression *transformFunctionCall(FunctionCall const *fcall)
    {
        Expression * a;
        if (dynamic_cast<Number*>(fcall->arg()->transform(this)))
            {a = fcall->arg()->transform(this);}
        else
            {a = (Number*)(fcall->arg()->transform(this));}
        FunctionCall * b = new FunctionCall(fcall->name(), a);
        return new Number(b->evaluate());
        delete b;
    }
    Expression *transformVariable(Variable const *var)
    {
        return new Variable(var->name());
    }
};

bool check_equals(Expression const *left, Expression const *right)
{
    return (typeid(*left) == typeid(*right));
}

#include <iostream>

using namespace std;

char *getline() {
    // put your code here
}

#include <iostream>

using namespace std;

char *getline() {

	int i = 0;
	char c = '\0';
	char * b = new char[1000];
	while (cin.get(c)) {
		i++;
		if (c == '\n')
			break;
	    b[i-1] = c;
	}
	cout << i-1 << ":" << b;
	delete [] b;
}