informatique 6

const int VALUE    = 60;
const int VECTOR = 600;
const int MATRIX = 6000;

class InputInfo
{
public:
                inline InputInfo()
                {
                }
                inline InputInfo(const string& name, const int type)
                {
                               itsName = name;
                               itsType = type;
                }
                inline string& GetName()
                {
                               return itsName;
                }
                inline int GetType()
                {
                               return itsType;
                }
private:
                string                       itsName;
                int                           itsType;
};

template<class T> class InputContainer
{
public:
                inline InputContainer()
                {
                }
                inline InputContainer(const InputContainer<T>& inputs)
                {
                               if (this != &inputs)
                               {
                                               itsInputs = inputs.itsInputs;
                               }
                }
                inline InputContainer<T>& operator=(const InputContainer& inputs)
                {
                               itsInputs = inputs.itsInputs;
                               return *this;
                }
                inline map< string, Container& GetInputs()
                {
                               return itsInputs;
                }
                inline bool AddContainer(const string& name, Container<T>& container)
                {
                               if (IsNameValid(name))
                               {
                                               GetInputs()[name] = container;
                                               return true;
                               }
                               else
                                               return false;
                }
                inline Container<T>* GetContainer(const string& name)
                {
                               return &(GetInputs()[name]);
                }
                inline bool IsNameValid(const string& name)
                {
                               iter i = GetInputs().find(name);
                                               if (&i)
                                                               return true;
                                               else
                                                               return false;
                }
                inline InputInfo GetInputInfo(const string& name)
                {
                               int type = (GetInputs()[name]).GetType();
                               InputInfo info = InputInfo(name, type);
                               return info;
                }
                inline vector<string>& GetInputNames()
                {
                               map<string, Container input_map = GetInputs();
                               vector<string> names;
                                string name;
                               /*for (iter i = input_map.begin(); i!=input_map.end(); i++)
                               {
                                               name = (*iter);
                                               names.push_back(name);
                               }*/
                               return names;
                }
private:
                typedef map<string, Container::iterator                       iter;
                typedef map<string, Container::const_iterator                             citer;
private:
                map<string, Container                  itsInputs;
};

void main()
{
                //class Matrix
                vector<double> inputs(total);
                inputs[0] = 1;
                inputs[1] = 0;
                inputs[2] = 0;
                inputs[3] = 0;
                inputs[4] = 0;
                inputs[5] = 3;
                inputs[6] = 0;
                inputs[7] = 0;
                inputs[8] = 0;
                inputs[9] = 0;
                inputs[10] = 5;
                inputs[11] = 0;
                inputs[12] = 0;
                inputs[13] = 0;
                inputs[14] = 0;
                inputs[15] = 7;
                matrix<double> M = matrix(inputs, 4);
                vector<double> tV(4);
                tV[0] = 1;
                tV[1] = 2;
                tV[2] = 3;
                tV[3] = 4;
                vector<double> V(4);
                V[0] = 2;
                V[1] = 4;
                V[2] = 8;
                V[3] = 16;
                Container<double> vec1(VECTOR, tV);
                Container<double> vec2(VECTOR, V);
                Container<double> mat(MATRIX, M);
                InputContainer<double> inputCont;
                inputCont.AddContainer("Vector 1", vec1);
                inputCont.AddContainer("Vector 2", vec2);
                inputCont.AddContainer("Matrix", mat);
                Container<double>* cev1        = inputContainer.GetContainer("Vector 1");
                Container<double>* cev2        = inputContainer.GetContainer("Vector 2");
                Container<double>* tam         = inputContainer.GetContainer("Matrix");
}

Noter cette page

0/10 sur 0 vote