Yes it is possible.
In fact the only justification for the continued existence of C++/CLI is that you can integrate standard C++.
[EDIT] This is just my humble opinion. Why? If you want to use managed code then you are better off using C#, because it's syntactially simpler and spares you some of the problems that standard C++ poses...

You can't have a dynamic array. If you want to do that you need to use vector or use new/delete dynamic allocation. Space for arrays is reserved at compiletime so that's why you need a constant expression there.

float **A = 0.0; // pointer for A

You cannot do that. The initialisation takes a double calue (0.0) and tries to assign it to a pointer (A) that is a type mismatch.
use instead:
A = 0 / or NULL, although some people frown upon using NULL/; // pointer for A

go ahead! we'll have a look.

weeeeelll.... You are asking a bit much, coz writing a GUI depends entirely on the application and its requirement, but I will try to point you in a direction to get you started.
MSVC uses "wizards" to create different kinds of projects. You must have used some already as you have a commandline application. One way to create a GUI is to use a wizard like Single Document or multiple Document application. Those are MFC (Microsoft Foundation classes) projects and the wizard will create a project for you that you can compile and run without the need to write a line of code. You should first try a Dialog-based application. This also will create the code that compiles and serve as a basis for your program. After creation you will see an empty panel on which you can drag and drop graphical elements like buttons, text windows, etc.
Just do that for a start and recompile. When you run the executable you'll see the GUI as you created it, but it won't do much. Now in MSVC double click on one of the buttons you dragged on the panel. This will open a code window for you inside the handler function for the onClick event. replace the to-do comment with the following:
AfxMessageBox("Hello from sofiastrange");
Recompile and execute. Press on the button and Wahey! you created your first user-interface.
That's just a start and you'll have a lot to pick up if you've never done it before, but ...

have a look at the boost Spirit library, there is an example where they do exactly that. basically you create a tree where operators are nodes and expressions subtrees with literals as leaves. It's a parse job of a Dyck-language basically (more or less).
Can't find the exact location now, but it's one of the examples.

All data in a digital computer is bits and bytes, effetively 0/1 strings. Datatypes of any sort are just interpretations of these data. Your job here is to serialise your object into a string of bytes before transmittions and recreate the object after it has been transmitted. Easiest to understand is probably the following: Write all the member variables of your object into a character-string (using string stream operators or sprintf, or whatever method you are familiar with). This way you have serialised the object into char's. Transmit this string and at the receiving end read the values back into memory and create an object using those values.
You have to think about what you want to do in case your object has complex members and/or pointers to other objects, but the general approach is the same.
Obviously this method is not very efficient, but once you've done it this way you can think about ways to improve permance.
Also you can have a look at the boost serialisation library if you are interested.

probably this helps:
You should however very sparingly use recursion as a means of looping.
Recursion can always be replaced by iteration which is much lighter on resources and also much easier to debug.

Converting from Java to C++ is not just a matter of translating the syntax from 1 language to the other, but also the use of corresponding libraries. GUI libraries in C++ are not standardised and therefore there won't be a standard translation of your code. Which operating system are you working on? Which compiler and GUI library are you using?
The syntax of Java and C++ are quite similar so translating from Java to C++ is actually fairly straightforward. The reverse is not true.

for a start I am very curious about your system call there. You don't need it or you don't need your outf variable. Either the one or the other is superfluous.
Since you run "whoami" probably get rid of outf.
Are you running your program from the commandline? If so your outputfile would be in the current directory, if you use an IDE like VS then you can configure in the properties where your working directory is. Otherwise set an environment variable/configuration/registry to where you want your files and make you code read it and customise your system call.

the correct function is size()

What are the errors you are getting?

You will have to create a string comparison function or better a functor (if you have yet learned what a functor/function object is). And you have to use that for doing your comparison and not the standard string comparison.

No. The gradient is the highest CHANGE in grey value. The maximum is what you want.
Just initialise a variable maxval=0; then in a loop whenever you find a value > maxval then set it to the new maxval. Iterate through all greyvalues on your line. done.
If however you need to FIND the pixels that belong to the line then the gradient will come in handy depending on the algorithm you use...

Say you want only one period of the 1kHz wave. Since 1kHz = 1000/s this means you have 1000 periods per second. If you only want 1 then you have to evaluate your function in any arbitrary (1/1000)s interval [t0..t1] on the time axis. So you put your function in a loop and evaluate at distinct points between t0 and t1. For ease you can use t0=0.0 and t1=0.001. say you want 42 sample points in your interval then set t_step to (t1-t0)/42. In code that will look something like:
double t0 = 0.0;
double t1 = 0.001;
double numOfSamples = 42.0;
double t_step = (t1-t0)/numOfSamples;
for(double t = t0; t<=t1; t += t_step)
cout << t << "\t: " << generate_sin(t) << endl;
This should print out 42 (or 43 - I didn't debug) lines of values of your sine wave in the interval [0.0 .. 0.001] provided you got your generate_sin function right.
There is no way in C++ (or any other computer-language for digital computers, for that matter) that can generate the entire wave. It always has to be samples, that means distinct/pixelated values.

Well there are a few things in your code that are a bit off. First: the sin function is a function that is usually defined on the real number range. You define the function on integers which is probably what you want, but I still wanted to point it out. Secondly you can get into trouble if you name variable like common functions like sin, cos, etc because of naming conflicts. But to your original question:
The function f: t->sin(t) has a period of 2Pi so say t is in units of seconds then the frequency of the sin-wave is 1/(2Pi) which is ~ 1/6, so the wave has a frequency of a 6th Hz. To modulate the wave to 1 kHz (1000Hz) you have to multiply the argument of the sin function with 2Pi1000. But that really depends on what your function argument t is: nano, milli-seconds, ...

Read in from a file pairs of integer. Those N pairs represent 2D-vectors (in an XY- plane). Connect the vectors end-point of one connects to the startpoint of the next. Find the subset of size M<=N vectors that maximises the area this polygon encloses, if such a polygon exists.
The number of vectors N can be very big > Million.

Your class DirectGraph has an overloaded [] operarator, but your variable directedGraph is a [B]pointer[/B] to a DirectGraph object. Your call should look something like:

BTW: I see no good reason why you use a dynamically allocated object, but it's difficult to judge from the piece of code.

How do you decide that a certain restriction is needed and another is not? It's not obvious from the query and that makes it difficult for any compiler do decide what can be optimised away and what not. Optimisations of queries are best done within the database. Most major DB systems have dedicated profilers and optimisers. For optimisations not only table definitions are taken into account, but also indices, actual tablesizes or table size hints and other things. It would be difficult to wrtie a "dry-run-optimiser" in C++ or any other language for that matter. Your best bet would probably be LINQ of C# fame, but that would hold links or copies of DB objects.
If that does not answer your question or if you were actually after something else then please re-phrase the question and we'll try to help.

Nothing wrong per se in allocating in the initialisation list. Everything that is new'd can be delete'd. It's a bit of a curious way thing are done here, but I assume this is a learning project and you have to go through a few things to understand why one way of doing things is better than the other one. You can allocate, initialise with NULL and other things. I'd be more curious about the hardcoding of allocated and used. If you want that, then you surely would be better off using fixed length arrays, no?
Also you have to be a bit careful: There is a slight trap for beginners. I haven't seen your class declaration, but if your variable "data" is declared [B]BEFORE[/B] the variable allocated, then you code will not work as expected. A half-way decent compiler will warn you about this but not every compiler does. The problemis that members are initialised in th order they are declared and not in the order they appear in the init-list. So if allocated is declared after data then your allocate will have a "random" value. The new will then create an array of random size (or fail).

looks ok to me, what does your Str(char*) constructor do? and what does your Str copy constructor do?

How did you declare your variable temp? Since this->data and have dynamic lengths your temp-variable needs to be allocated dynamically.
char * temp = new char[used+append.used];

Also this string then must be deleted somewhere
delete [] temp;

also your function does not return anything, so you should at least get a warning in your cpmpiler. the operator should return a Str - object.
Those are the main problems in the moment, but there are further problems. Usually you are advised not to make binary operators like + and / members of a class but global functions because of the assymetry that the implicit this-argument poses.
but one step at a time...

You already sorted your array. The median is the element in the middle of your array.
The size of your array is ROWCOL with both ROW and COL > 0, then the median is the element at index [ROWCOL/2]. You have to think what you want to do if ROW*COL is odd or even, but that's it.
Since your array is sorted, finding the mode is easy: iterate through the array after initialising the modewith the first (smallest) element. You need two counters
int workCount = 0;
int maxCount = 0;
in your loop you use the workCount to count the number of times the smallest value is in your array. That's easy coz they are all at the start of your array. Stop counting when you find the first element that is not equal to it's predecessor. the new maxCount is your current workCount. Then reset the workCount to 0 and count the second smallest values in your array. They are also all consecutive coz you got a sorted array. at the end compare the workCount with the maxCount. if the workCount>maxCount then your new mode is the second element and your new maxCount is the current workCount, other wise leave them as they are. Then count 3rd smallest element and so on...
I don't write the code for you so you can practise ;-)

what is the "mode"? median? mean?

int array[ROW][COL];
[B] int sumr[]= {0};
int sumc[]={0};[/B][/CODE]
you need to dimension sumr and sumc correctly!

int sumr[ROW]= {0};
int sumc[COL]={0};

your code adds up everything into one sum. You should get a monotonous increasing list of values (ROW*COL - many). trouble is you concatenate them all into one big number your cout << sum <<""; should be cout << sum << endl;

What errors do you get? Does the program compile?

C++ already provides you with the means to do that.

I don't know your library unfortunately and also don't know whether it
has any function that can do what you want for you. The algorithm to calculate the coordinates of your centre of gravity of the white pixels if the following
for (x=0; x<maxX; x++)
for(y=0; y<maxY; y++)
accumulatedX += x;
accumulatedY += y;
centerGravX = accumulatedX / numberWhite;
centerGravY = accumulatedY / numberWhite;


this is obviously pseudo code and I let you do the actual implementation in C++ ;-)

So you actually want to calculate the centre of gravity of your area. So what you need to do is add the (2D-)vectors of of your black pixels and divide by the number of pixels. That will give you the centre of gravity of your black area.