C++ to C code conversion, is it equivalent? [closed] - c++

Question

Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
This question does not appear to be about programming within the scope defined in the help center.
Closed 8 years ago.
Improve this question
I had to convert a C++ program to C, which has been done. The question is whether the codes presented are equivalent and whether I missed anything.
Both codes presented are complete and should compile. Both give the same answers when run, too. But I am new to C++ and I don't know if I missed something in my conversion that might be important.
One more question, in the C++ code, int x and int y were declared as global, I don't have, and don't think I need anything analogous to that, but I don't really know what they are doing. Guidance?
C++
#include <iostream>
// a point on the integer grid
struct Point
{
// constructor
Point()
{
x = y = 0;
}
// add point componentwise
void add(const Point &p)
{
x += p.x;
y += p.y;
}
// print to standard output
void print() const
{
std::cout << "[" << x << "," << y << "]" << std::endl;
}
// data
int x, y;
};
int main()
{
const int N = 200;
Point *A = new Point[N], sum;
for (int i=0; i < N; ++i) {
sum.print();
A[i].x = i; A[i].y = -i;
sum.add(A[i]);
}
sum.print();
delete [] A;
}
C
#include <stdio.h>
#include <stdlib.h>
typedef struct //constructor
{
int x;
int y;
} Point;
void add(const Point * p, Point * sum)
{
(*sum).x += (*p).x;
(*sum).y += (*p).y;
}
void print(const int x, const int y)
{
printf("[%d,%d]\n", x, y);
}
int main()
{
int i = 0;
const int N = 200;
Point *A = malloc(N*sizeof(Point)), sum;
if(!A)
{
printf(stderr, "malloc() failed to allocate memory!");
abort();
}
sum.x =0;
sum.y = 0;
for (i = 0; i <N; i++)
{
print (sum.x, sum.y);
A[i].x = i; A[i].y = -i;
add(&A[i], &sum);
}
print(sum.x, sum.y);
free(A);
return 0;
}

Answer 1

It is fairly equivalent functionally (aside from the constructor issue, see below). But for some reason it contains a number of inconsistencies and "illogical" stylistic decisions.
The "standard" approach to approximate a C++ method by a C function is to implement the C++ implicit this parameter through an explicit parameter. That would make your add function look as follows
void add(Point *this, const Point *p)
{
this->x += p->x;
this->y += p->y;
}
Note that in C++ version you could also use the this->x syntax on the left-hand side (instead of just x), which would only emphasize the similarity. Obviously, my version above is the same as yours, but arranged in what I believe is more "traditional" fashion.
You forgot to define a "constructor" for your Point in C version of the code. In C++ code your Point objects begin their lives initialized to zero. In C code these objects begin their lives with garbage in x and y. Later you assign definitive values to x and y, which makes the non-initialization issue non-consequential, but still it is there.
Of course, if you decide to implement a "constructor" function, you will have to call it manually for each array element, while in C++ it is called automatically for you.
For some reason you decided to "disassemble" the object into x and y parameters for print function. Why? Again, the same approach with an explicit this parameter can be used for print and it would look as follows
void print(const Point *this)
{
printf("[%d,%d]\n", this->x, this->y);
}
In your current version
void print(const int x, const int y)
const qualifiers applied to parameters achieve virtually nothing useful and do not promote equivalence to the C++ version (i.e. these const qualifiers are not equivalent to that trailing const in the C++ version).
But, in any case, these are purely stylistic suggestions.
Note also that in C++ language
const int N = 200;
defines a constant, while in C language it does not define a constant. In C it defines what essentially is a "non-modifiable variable". But this is completely non-consequential for your code, since your code does not care whether N is a constant or not. (I don't know whether you care about this sort of pedantic equivalence.)

Answer 2

It depends on the level of 'equivalency' you're looking for. In the C version you don't have a function equivalent to the Point constructor and you avoid the default initialization on the array of points, your C print function operates on ints instead of a Point object, and I see some const mismatches such as the fact that your C add function takes a pointer to non-const Point on the right hand side while the C++ version takes a reference to const Point.