Managed C++/CLI

class SimpleState: public State {
    public:
            int position; 
            int context;
            int time;
    
            SimpleState();
            SimpleState(int _position, int _context, int _time) :
            rat_position(_position),
            context(_context),
            time(_time) {
            }
            SimpleState(int _state_id);
            ~SimpleState();
    
            std::string text() const;
    };
        SimpleState::SimpleState() {
        }

    class StarMazeProblem : public DSPOMDP,
         public MDP {
    protected:
            std::vector<std::vector<std::vector<State> > > transition_probabilities_; //state, action, [state, weight]
    
            mutable MemoryPool<SimpleState> memory_pool_;
    
            std::vector<SimpleState*> states_;
    
            mutable std::vector<ValuedAction> mdp_policy_;
    
    public:
            enum {CENTER = 0, RIGHT = 1, LEFT = 2};
            
    public:
          StarMazeProblem();
          int NumStates() const;
          void ComputeDefaultActions(std::string type)  const;
          ParticleUpperBound* CreateParticleUpperBound(std::string name = "DEFAULT") const;//?
          ScenarioUpperBound* CreateScenarioUpperBound(std::string name = "DEFAULT",
                  std::string particle_bound_name = "DEFAULT") const;
    
          ScenarioLowerBound* CreateScenarioLowerBound(std::string name = "DEFAULT",
                  std::string particle_bound_name = "DEFAULT") const;
         }

int StarMazeProblem::NumStates() const {
    	 return CONTEXT * POSITIONS * TIME;
    }
    void StarMazeProblem::ComputeDefaultActions(string type) const {
    	cerr << "Default action = " << type << endl;
    	if (type == "MDP") {
    		const_cast<StarMazeProblem*>(this)->ComputeOptimalPolicyUsingVI();
    		int num_states = NumStates();
    		default_action_.resize(num_states);
    
    		double value = 0;
    		for (int s = 0; s < num_states; s++) {
    			default_action_[s] = policy_[s].action;
    			value += policy_[s].value;
    		}
    	} else {
    		cerr << "Unsupported default action type " << type << endl;
    		exit(0);
    	}
    }
    ScenarioLowerBound* StarMazeProblem::CreateScenarioLowerBound(string name,
                                         string particle_bound_name="DEFAULT") const {
            const DSPOMDP* model = this;
    	    const StateIndexer* indexer = this;
    	    const StatePolicy* policy = this;                                 
            ScenarioLowerBound* bound = NULL;
            if (name == "TRIVIAL" ) {
                bound = new TrivialParticleLowerBound(this);
            } else if (name == "RANDOM") {
                bound = new RandomPolicy(this,
                              CreateParticleLowerBound(particle_bound_name));
            } else if (name == "MODE" || name == "DEFAULT") {
    		    ComputeDefaultActions("MDP");
    		     bound = new ModeStatePolicy(model, *indexer, *policy,
    			              CreateParticleLowerBound(particle_bound_name));                             
            }  else {
                cerr << "Unsupported scenario lower bound: " << name << endl;
                exit(1);
            }
            return bound;
    }

src/starmaze.cpp:301:36: error: passing 'const std::vector<int>' as 'this' argument discards qualifiers [-fpermissive]
       default_action_.resize(num_states);
                                        ^
    In file included from /opt/local/include/gcc7/c++/vector:64:0,
                     from ../../../include/despot/interface/lower_bound.h:4,
                     from ../../../include/despot/core/builtin_lower_bounds.h:4,
                     from src/starmaze.h:3,
                     from src/starmaze.cpp:1:
    /opt/local/include/gcc7/c++/bits/stl_vector.h:689:7: note:   in call to 'void std::vector<_Tp, _Alloc>::resize(std::vector<_Tp, _Alloc>::size_type) [with _Tp = int; _Alloc = std::allocator<int>; std::vector<_Tp, _Alloc>::size_type = long unsigned int]'
           resize(size_type __new_size)
           ^~~~~~

Image Transformation
Digital images are represented as a matrix and each element in the matrix represents the RGB value of a pixel. Given the pixel values of a nXn image. Write a code to transform the image into another image by alternate swap of edge pixels. That is for example, given a 4 X 4 image as follows:

1 2 3 4

5 6 7 8

9 10 11 12

13 14 15 16

The edge elements of the above image are 1, 2, 3, 4, 8, 12, 16, 15, 14, 13, 9 and 5. The following steps are involved in the transformation:

1 and 3 are swapped

1 and 8 are swapped

1 and 16 are swapped

1 and 14 are swapped

1 and 9 are swapped

After doing alternate swap of edge elements the pixel values of the image looks as follows:

3 2 8 4

5 6 7 16

1 10 11 12

13 9 15 14

And given an image of dimension 5 X 5 as follows:

2 4 5 6 3

3 11 12 7 9

7 15 13 8 1

2 21 25 13 14

17 10 16 19 3

Should transform as:

5 4 3 6 1

3 11 12 7 9

2 15 13 8 3

2 21 25 13 14

7 10 17 19 16

Input Format

First line contains the dimension of the matrix, n

Next nxn lines contain the elements of the matrix in row major order. That is the elements in the first row are given followed by second row and so on

Output Format

Print the transformed nxn matrix in ‘n’ lines

Each line contains the elements of a row separated by a tab.

Note: There is a tab at the end of each line

public ref class Managed_base abstract
{
    unsigned int _Data = 0;
    
    virtual Native_base* GetNativeObject(unsigned int data) = 0;
}

public ref class Managed_derived : Managed_base
{
    virtual Native_derived* GetNativeObject(unsigned int data) override
    {
        Native_derived* NativeObject = new Native_derived();
        NativeObject->_Data = data;

        return NativeObject;
    }
}

TO OPENGL 4.6 Not responsive please help

Write a program in C++ that reads data from a file (ask user to enter file name). The number of elements in file are unknown so, you are supposed to regrow the array and dynamically allocate the memory every time it is needed. 
Now, your task is to keep asking user two numbers, one is a num and second is location. Insert the num into that location and move the other elements to the right by re growing the array whenever needed. The function should keep asking user the number and location until user enters -99 in num.
Number = 74, Location = 3
Updated Data:       2 3 74 15 1 82 8 9 10 21 55 12 14 16 18
Number = -22, Location =5
Updated Data:       2 3 74 15 -22 1 82 8 9 10 21 55 12 14 16 18
Number = -99
Program Ended