While C++ isn’t a proper superset of C, the differences are so minor that they’re easy to deal with. So, your first step is to simply compile your C code with a C++ compiler. In that sense, the conversion is trivial.

You’ll need unit tests. It’s wonderful if the original code has them. Start by converting them from whatever C unit test framework was used to a C++ unit test framework. Do that without changing the code under test. If you don’t have unit tests with the original code, write them using a C++ unit test framework. You don’t need to convert any of the code under test to do that, except the trivial changes to make it compile with a C++ compiler.

However, you probably want to convert it in a more meaningful sense. One of the insights I got from reading Working Effectively With Legacy Code by Michael Feathers is that procedural code is object-oriented in a very crude sense. What he said is that the entire program is one big singleton object. In reality, if the code is reasonably modular, each subsystem can be treated as a singleton object.

So, you start by converting the code with that assumption. It’s worth getting a copy of his book, along with Refactoring To Patterns by Kerievsky and, of course Refactoring by Fowler. You’re going to be refactoring the code extensively. Even making each module into a class so that you can have a singleton object for each module has the potential to break things.

Once you’ve got all of the subsystems refactored into singleton objects, you can do additional refactoring. From there, it’s the kind of refactoring that is well documented for OO languages.

I did this a couple of years ago for a couple hundred line C program. I figured that C++ is just a superset of C and that I could change the file extension from .c to .cpp. That it would compiler. Well not exactly. First thing I found is that this program had a lot of definitions that since it was written was now included in some Windows headers. Once I fixed that I found places where C++ required casts that C didn’t.

After a day or so I got the program to compile and run. The next step was to rewrite the program to use C++ so that it would be easier to understand and maintain.

My recommendation is to only convert that parts of the program to C++ that you need to maintain. Keep the rest of it in C and link them together into one program. In order to call a C function from C++ you have to declare it

extern “C”

carefully - there isn’t a tool to do it.

personally I would start with the unit testing - either find a way that the unit tests for the python code can be re-used simply to test the C++ code (this isn’t always easy) or rewrite your Python unit-tests into C++; a framework like catch might be a good choice.

I would then start by picking a single simple class or function in Python and rewriting it in C++ = remember that the C++ standard library has Hashmaps, sets and vectors which can be used in many cases as replacements for Python builtins.

I would go function by function and class by class - and eventually all of your test cases will pass.

That depends on what sort of code you start with, and what sort of result you want.

If you're starting with K&R code, and just want the code to become acceptable to a C++ compiler, you need to do a couple of things.

1. Declare all functions (with parameter types).
2. Use ANSI definitions for all functions.

In K&R C, a function declaration looks something like: int f();. It says that `f` is a function returning an int, but says nothing about the number or type of parameters it accepts. C++ demands a function declaration similar to an ANSI C function prototype, such as: int f(int, long);, which says `f` takes two parameters of type `int` and `long` respectively.

In K&R C, a function definition could look something like this:

int f(x, y) 
int x; 
long y; 
{ 
   // ... body here 
} 

C++ demands the "new" style of definition like this:

int f(int x, long y)  
{  
    // body here 
} 

Back in the early '90s there were a few tools available to do this sort of conversion automatically. The one I recall was named "cproto".

I don't know of any that even attempted to create meaningful class structures, or anything like that though. Nor do I know of any that attempted to automate a few things you might have to rename, such as if you'd used a variable named "class" or a function named "delete". Most of these are just handled with an editor if they arise.

Yes, the C compiler, the C++ compiler - and you :)

If you want C code to compile in a C++ compiler, you should first start by converting the C code to strict ANSI compliance by enabling the --ansi --pedantic --Wall options in gcc or the equivalent options in your compiler.

After you've done this and run a full regression test on your code to confirm that it still works - it's easy to introduce bugs doing these sorts of conversions - you can try to see how far you get by compiling with a C++ compiler.

There are enough differences that this may not be trivial even after ANSI-izing: Compatibility of C and C++ - particularly for "system"-style code that does a lot of cleverness with casts that C++ doesn't like.

After this is done, you have C code that builds with a C++ compiler. You now need to re-run your full regression test suite on this second pass, and you're done. Naturally, you don't have fancy OO code yet...

That said, a big question is why? If you have a C library you want to call from C++, you can use extern "C" to allow your C++ to call your C and vice versa (for C-compatible entry points into C++) - and not go through a potentially laborious and bug-inducing conversion process.

The string would have to contain a complete C program and would need to be error free (no syntax or linking errors) in order to be saved to a file and run through the compile/link procedure before being executed (noted in another answer). I imagine it would be executed as a separate thread or spawned process.

Interestingly, a feature of the newest version of the MS C/C++development environment back in ’98 (released after I left MS) included the “edit and continue” feature which basically accomplished what you are asking about… sort of.

It allowed you to modify the code as it was running (from the debugger) and have that new code linked dynamically into the currently running process so you could continue the existing process using the new code. It was a truly amazing feature which required the brainpower of the dev lead for the linker to imagine and write.

As I recall, it would take the entire function being edited, recompile it into a separate DLL and modify the link table of the current process to call the function in the new DLL rather than the original version. Please don’t hold me to that loose description as I was not intimately engaged in the actual development of the feature, but I believe that was the gist of how it was accomplished.

Obviously, there were limitations as to the scope of the edits being made at any one time, and I’m not sure you could edit the main program body. Nonetheless, it was a brilliant bit of work by the most adept developer I ever met and had the pleasure to work with.

If you only use features from before Java 1.5, you can use JCGO to translate Java source to C.

You can always decide to rewrite your project. I would target modern C++ though, which is a much closer match to Java than C is. If your project is large and you don't want to wait until your entire rewrite is finished, you may need to either do an inside-out replacement where you rewrite the innermost code in C++ first and call from the outer Java program via JNI. Or break it up into loosely coupled services and rewrite each service in C++. Either way you can make incremental progress without having to wait for the full rewrite to finish first.

You don’t? At least… Not without a large amount of support code in various libraries that already exist in any number of G-Code interpreters that actually interpret the code for the various machines that use it.

G-Code is a hardware control language and not a general programming language. It’s more akin to the graphics language Logo or the drawing control language of the classic “Windows Metafile”. Its commands are things like “change x-axis position by 0.10mm positive” or “set spindle speed to 300 RPM” — just like Logo has “pen up”, “pen down” and all the other commands for telling the “turtle” where to go.

What do you mean by ‘Arduino code’?

The default language that pretty much everyone uses to program Arduinos is C++. If you write a simple program for an Arduino, without using any C++ specific language features, then the code you’ve written will probably compile as C by any C compiler.

But then you’d also need that compiler to supports the Arduino libraries and emits the proper ATmega or ARM machine code, etc, so I don’t know why you’d do that.

If you’re just a bit put off by the thought of having to write C++ code to work with your Arduino - don’t be. You don’t need to know any special C++ features to write simple Arduino programs.

Actually, you can’t. In reality I mean. Of course, if you’re genius, and you’ll write your own converter, with preprocessor, parser, memory-manager, test-system, decompiler, debug-injector, etc, you’ll can convert it. But, it’s a mess, you shouldn’t do this. If your project about 500k SLOC, you should maintain it in java your whole life, if it less than 30k SLOC, just rewrite it, with unit-tests. You can’t trust any project, which was converted automatically from one language to another. It’s unprofessional, there’s no machine/program, which can do it properly. Of course, any company may sold you solution. But, how will you maintain that unreadable mess in the future? Did you see translated programs before? I can give you an example: Nim language, you write your code on pretty language, called Nim, it looks like python in two words, then, translator is converting your source code from Nim to C, and it looks like tons of variables like _10000987garatehj_90__finder__wrap__xx_0, do you want this as a result? I don’t think so. Because, all what you’ll get as a result - you’ll rewrite your project by yourself, and spend your time twice.

Technically, the C++ code IS the software. If you mean how do you get an executable image, for UNIX or Windows, you need a compiler.

For simple C++ programming, there’s a number of “obvious” options.

1. Windows - Use Visual Studio Community Edition. That’s what I use at home. You will want to create a project who’s type is “Console App”. It’s a pain to sort through all the project types, and Visual Studio has a learning curve. But once you learn it, you can do a lot with it. I routinely write sample code for Quora questions using this approach.
2. Windows - Install Windows Subsystem for Linux. Use g++ to compile ( possibly with option -std=c++11, if needed.) You can edit in windows. I use Sublime. This is how I develop C++ at work. Downside is mainly installing the subsystem, and learning some Linux commands if you don’t know Linux. Software development is like that. If you want easy, use Python.
3. Linux - Use g++. Make sure like mentioned above, C++11 is enabled. Edit with vi or emacs. I only use this option when forced to do it. I have used vi since the 1980s. Can’t say I find it easier than using Sublime for editing.

Good luck!

There’s many other options. Just giving you the ones I use.

You are in luck, because the same compiler is used for both languages.

It will be simpler if you do not include any C++ libraries in your code, including the STL headers. Only use the <c…> headers.

That is probably not what you are trying to do, however.

What is usually done for this is to write external C wrapper functions for the c++ calls, and translate the data members to C structures.

Say we had a Point Vector C++ struct that we wanted to use in a C program.

// Pvector.cpp 
#include <vector> 
#include <algorithm> 
 
struct Point 
{ 
  int x, y; 
   
  Point add(const Point& p) 
  { 
    return Point{ x + p.x ,  y + p.y };     
  } 
 
  Point subt(const Point& p) 
  { 
    return Point{ x - p.x ,  y - p.y};     
  } 
 
}; 
 
 
Point* copy_array( Point* a, Point* b, size_t n) 
{ 
 
  Point* ap = a; 
  Point* bp = b; 
  Point* end = a+n; 
 
  while( ap < end)  *(bp++) = *(ap++); 
 
  return b; 
} 
 
 
std::vector<Point> make_PointVector(const Point* parray, size_t n) 
{ 
  std::vector<Point>  pvec; 
 
  pvec.reserve(n); 
 
  std::copy_n( parray, n, pvec.begin() );  
 
  return pvec; 
} 

OK we can compile it to a binary object file:

g++ -c  Pvector.cpp 

to obtain Pvector.o, which defines a Point struct and two C++ functions, one to make a vector of Points, another to copy point arrays.

We create an interface file “pv_interface.cpp, with some helper functions and designate that the function will have C linking conventions, so that their names will not get mangled the way C++ normally does it.

// pv_interface.cpp 
 
#include <cstddef> 
#include <cstdint> 
#include "Pvector.cpp" 
 
extern "C" {  // C linking  
 
Point* copy_point_array(Point* a, Point* b, size_t n) 
{ 
  return copy_array(a, b, n); 
} 
 
 
Point* new_point_vector(Point* parray, size_t n) 
{ 
  return make_PointVector(parray, n).data(); 
} 
} // extern "C" 

Compile it:

g++ -c pv_interface.cpp  

to pv_interface.o.

Now we integrate it into out C driver

/* main.c */ 
#include <stdio.h> 
 
/*  declare C struct type with same members */ 
typedef struct {int x, y; } Point; 
 
/* function prototypes from pv_interface */ 
Point* copy_point_array(Point* a, Point* b, size_t n); 
Point* new_point_vector(Point* parray, size_t n); 
 
 
int main(int argc, char** argv) 
{ 
 
  Point* parray = new_point_vector(parray, 10); 
   
  for(int i = 0; i < 10; i++) 
    { 
      Point tmp = (Point){ i, 3*i}; 
      parray[i] =  tmp; 
      fprintf(stdout, "%d :\t { %d , %d} \n" , i, tmp.x, tmp.y); 
    } 
 
   
  return 0; 
} 

We provide a definition of Point struct matching the actual data members of the C++ class. We provide function prototypes (signatures) for the interface we have built.

We then compile it with the object files and the standard c++ shared library.

 gcc -o pv main.c pv_interface.o -lstdc++  

Realize that pvinterface.o includes Pvector.cpp in it, so has the code for Point and its utilities compiled in, and you cannot call any STL without adding in the shared library which contains just about all of the C++ code you need.

try it:

/pv 
0 :	 { 0 , 0}  
1 :	 { 1 , 3}  
2 :	 { 2 , 6}  
3 :	 { 3 , 9}  
4 :	 { 4 , 12}  
5 :	 { 5 , 15}  
6 :	 { 6 , 18}  
7 :	 { 7 , 21}  
8 :	 { 8 , 24}  
9 :	 { 9 , 27} 

Check it for leaks and such:

valgrind  ./pv 
 
/** A bunch of MACRO CRAP .... */ 
 
0 :	 { 0 , 0}  
1 :	 { 1 , 3}  
2 :	 { 2 , 6}  
3 :	 { 3 , 9}  
4 :	 { 4 , 12}  
5 :	 { 5 , 15}  
6 :	 { 6 , 18}  
7 :	 { 7 , 21}  
8 :	 { 8 , 24}  
9 :	 { 9 , 27}  
... 
 
==1371240==  
==1371240== HEAP SUMMARY: 
==1371240==     in use at exit: 0 bytes in 0 blocks 
==1371240==   total heap usage: 3 allocs, 3 frees, 73,808 bytes allocated 
==1371240==  
==1371240== All heap blocks were freed -- no leaks are possible 

Valgrind says all allocations are recovered, so you can be confident that
the interface is valid on first analysis.

Summary:

Provide a C interface to your C++ code that hides the C++ only stuff, and provides a C linkage to its own interface. Make object files that provide the code without forcing the C compiler to try to make sense of C++ source code.

Provide a C interface declaration (in a .h file, or in the C file compiled (main.c) that tells the C compiler the composition of the struct data, types translated to C syntax, and the function prototypes.

Compiler together with the objects and C++ standard shared library linked in.

The main problem is making sure that things in C are not double defined, specifically function implementations.

An additional note is that notice that the main.c creates Point structure tmp and assigns it values, then uses the pointer to the array in the vector as if it was a C array. The vector destructs when it goes out of scope, automatically.

Such integration is often a lot more hairy and you need to create more interface functions. A good knowledge of C and C++ and pointers and so on is essential, and this stuff is usually a forced decision because there is no other choice. But C and C++ are fast as fast gets generally so you can get away with layers of wrapping an never notice the overhead or speed of extra calls at runtime.

In your virtualenv, install SeaSnake, and then run it, passing in the name of a C++ source file (or files, if you want to provide the header as well as the cpp file):

$ pip install seasnake

$ seasnake -s path/to/MyClass.cpp

This will output a MyClass.py Python module to the console.

If your code requires external include files or definitions, you can use the -D and -I options.

>>>>>>>

Once you get started coding in Python ... and get some feel for its (often very) simple coding style and power ... you may then want to DO many of your programming jobs in Python first ... and many of those, then ... may never get recoded in C++ :)

Here is a little demo C++

struct 'Contact' ...

with a way one might recode it in Python 3

that may help get you past 'go' ...

Firstly the C++ code ...

// Cpp_vs_Python.cpp //

#include <iostream>

#include <string>

using namespace std;

struct Contact

{

string name;

string phone;

string toString() const

{

return name + ", " + phone;

}

} ;

typedef Contact* iter;

int main()

{

Contact book[] = { {"Sam", "1234567890"},

{"Bill", "2345678901"} };

iter it,

begin = book,

end = book + (sizeof book / sizeof *book) ;

cout << "Showing contacts in book ...\n";

for( it = begin; it != end; ++it )

cout << it->toString() << endl;

cout << "Press 'Enter' to continue/exit ... " << flush;

string dummy;

getline( cin, dummy );

}

Ok ... now here is how one might recode this in Python 3
(Note how much shorter and simpler is the Python code.)

# Cpp_vs_Python.py #

class Contact:

def __init__(self, name, phone):

self.name = name

self.phone = phone

def __str__(self):

return self.name + ', ' + self.phone

# get some data into a book (a list of Contact)

book = [ Contact("Sam", "1234567890"), Contact("Bill", "2345678901") ]

#show the book

print( 'Showing contacts in book ...' )

for item in book:

print( item )

input( "Press 'Enter' to continue/exit ... "

If you are trying to use as a part of your program, you can use atoi function to convert string to an integer. You will require to include cstdlib library in your program.

For eg.,

// C++ program to use atoi to convert string to integer

#include <iostream>

#include <cstdlib>

using namespace std;

int main()

{

const char *str1 = "56";

const char *str2 = "5.59";

const char *str3 = "3745 geek";

int num1 = atoi(str1);

int num2 = atoi(str2);

int num3 = atoi(str3);

cout << "atoi of (\"" << str1

<< "\") is " << num1 << '\n';

cout << "atoi of (\"" << str2

<< "\") is " << num2 << '\n';

cout << "atoi of (\"" << str3

<< "\") is " << num3 << '\n';

return 0;

}

And if you want to implement the functionality of string to an integer then:

// C function to implement atoi functionality

#include <stdio.h>

int toString(char a[]) {

int c, sign, offset, n;

if (a[0] == '-') { // Handle negative integers

sign = -1;

}

if (sign == -1) { // Set starting position to convert

offset = 1;

}

else {

offset = 0;

}

n = 0;

for (c = offset; a[c] != '\0'; c++) {

n = n * 10 + a[c] - '0';

}

if (sign == -1) {

n = -n;

}

return n;

}

int main()

{

char a[20];

int n;

printf("Input a string to convert to an integer\n");

scanf("%s", a);

n = toString(a);

printf("String = %s\nInteger = %d\n", a, n);

return 0;

}

You seem to have some sort of misconception here, but the short answer is that C code is used to explain an algorithm to a machine.

Your question is a little backwards; you actually want to convert algorithms from a series of steps in natural language into C code. If you’re converting C code to an algorithm, what you’re really doing is describing the algorithm in a natural language instead of a computer language.

To “convert” C code into an algorithm, then, all you have to do is look at the C code and write down what each line or block is doing. Going the other way, you take statements written in a natural language and implement them in code (more common); generally the C code will take more space and time to write out because of explicit variable declarations and memory management that don’t come up the same way in natural language.

original question:

Can anyone help me convert Python code to C or C++?

answer:

Not very likely, however, it isn’t very difficult to do some quick research to learn what the variable declarations are and attribute them to the C/ C++ equivalent.

#!/usr/bin/env python 
#original Boyer-Moore implementor (v1): Shriphani Palakodety 
 
import time 
 
bcs = {} #the table 
 
def goodSuffixShift(key): 
    for i in xrange(len(key)-1, -1, -1): 
    if key[i] not in bcs.keys(): 
        bcs[key[i]] = len(key)-i-1 
 
 
#---------------------- v1 ---------------------- 
def searchv1(text, key): 
    #base from Shriphani Palakodety fixed for single char 
    i = len(key)-1 
    index = len(key) -1 
    j = i  
 
    while True: 
        if i < 0: 
            return j + 1 
        elif j > len(text): 
            return "not found" 
        elif text[j] != key[i] and text[j] not in bcs.keys(): 
            j += len(key) 
            i = index 
        elif text[j] != key[i] and text[j] in bcs.keys(): 
            j += bcs[text[j]] 
            i = index 
        else: 
            j -= 1 
            i -= 1 
 
#---------------------- v2 ----------------------                         
def searchv2(text, key): 
    #removed string len functions from loop 
    len_text = len(text) 
    len_key = len(key) 
    i = len_key-1 
    index = len_key -1 
    j = i 
 
    while True: 
    if i < 0: 
        return j + 1 
    elif j > len_text: 
        return "not found" 
    elif text[j] != key[i] and text[j] not in bcs.keys(): 
        j += len_key 
        i = index 
    elif text[j] != key[i] and text[j] in bcs.keys(): 
        j += bcs[text[j]] 
        i = index 
    else: 
        j -= 1 
        i -= 1                         
 
#---------------------- v3 ---------------------- 
def searchv3(text, key): 
    #from v2 plus modified 3rd if condition - breaking down the comparison for efficency, 
    #modified the while loop to include the first if condition (oppposite of it) 
    len_text = len(text) 
    len_key = len(key) 
    i = len_key-1 
    index = len_key -1 
    j = i 
 
    while i >= 0 and j <= len_text: 
    if text[j] != key[i]: 
            if text[j] not in bcs.keys(): 
                j += len_key 
                i = index 
            else: 
                j += bcs[text[j]] 
                i = index 
    else: 
        j -= 1 
        i -= 1 
 
    if j > len_text: 
    return "not found" 
    else: 
        return j + 1 
 
 
key_list = ["POWER", "HOUSE", "COMP", "SCIENCE", "SHRIPHANI", "BRUAH", "A", "H"] 
 
text = "SHRIPHANI IS A COMPUTER SCIENCE POWERHOUSE" 
 
t1 = time.clock() 
for key in key_list: 
    goodSuffixShift(key) 
    #print searchv1(text, key) 
        searchv1(text, key) 
    bcs = {} 
 
t2 = time.clock() 
print 'v1 took %0.5f ms' % ((t2-t1)*1000.0) 
 
t1 = time.clock() 
for key in key_list: 
    goodSuffixShift(key) 
    #print searchv2(text, key) 
        searchv2(text, key) 
    bcs = {} 
 
t2 = time.clock() 
print 'v2 took %0.5f ms' % ((t2-t1)*1000.0) 
 
t1 = time.clock() 
for key in key_list: 
    goodSuffixShift(key) 
    #print searchv3(text, key) 
        searchv3(text, key) 
    bcs = {} 
 
t2 = time.clock() 
print 'v3 took %0.5f ms' % ((t2-t1)*1000.0) 

List of Keywords in Python

Remember that python is not a statically typed language, purely dynamic so look at the assignments to know what they are supposed to be.

t2 should be dealing with the time function.

def is a function declaration.

bcs is an array

key__list is a list

Everything else should be extremely easy to look at and interpret. While is a while loop, for is a for loop, ect…

As you can see, just from the base ones I told you the meaning of, it isn’t difficult to translate to C/C++, but no one is going to want to do the work for you for free.

If you’re trying to take compiled machine code and turning it back to C, give up. It’s just not worth it.

There are no tools that do this well and even if you could build a tool, compiling code is a lossy process. It’s fundamentally impossible to recover the source code from machine language as a lot of information is discarded, such as functions and variable names as well as formatting.

Even if you had a tool that could convert machine language into compatible C code, it would be incredibly difficult to read and understand, and would take a ton of additional work to clean it up.

This is not a project for someone to just take on individually for fun but could take months of work from a team of people to reverse-engineer machine code in a way that is actually human-readable.

A lot of stuff for the Arduino is open source, if you look into who developed the code you're trying to use, you probably could find the source code for it on their github or something. If the provider does not provide the source code, you could contact them and ask for it.

Otherwise, just don’t bother. It’s not worth it.

It is possible to convert Java code to C code manually, but it is a time-consuming and error-prone process. There are also some tools that can assist with the conversion, such as "Java to C++" and "Java2C", but they may not produce reliable results and may require significant manual editing to correct errors.

Here are some general steps for manually converting Java code to C:

• Replace all occurrences of "import" with "#include" to include the necessary C libraries.
• Replace the Java "class" keyword with the C "struct" keyword, and replace all method declarations with function declarations.
• Replace Java data types with their equivalent C data types. For example, "int" in Java becomes "int" in C, "boolean" becomes "int", and "String" becomes "char*".
• Replace Java operators with their equivalent C operators. For example, "&&" becomes "&&", "||" becomes "||", and "!" becomes "!".
• Replace Java method calls with function calls.
• Replace the Java "new" keyword with the appropriate C function calls to allocate memory for objects.
• Replace Java exception handling with C error handling.

This is just a high-level overview of the process, and you will likely encounter many other issues and complications as you work through the conversion. It is generally recommended to rewrite the code in C rather than attempting to automatically convert it.

Hello. So, you are a c++ programmer and want to convert it to an app. Now, it depends on platforms that you want to run your app on. You can easily build an executable for the machine you wrote your code on, or some similar configuration.

Now, you can run your code on android. For this, you will need a native development kit (NDK) which will be supported by Android Studio. You can download it from http://developer.android.com

iOS uses swift programming language, which is actually objective c (with modifications to suit the development environment). Now, you can convert your code to swift and get going.

However, c++ isn't used so broadly now a days. Languages like python and Go are taking over.

A2A. It depends to what degree… - Yes and No…

First of all - both languages are very different. So translation would not be an easy task, also when your C++ code would (for example) do something Python by design can’t (like executing Assembler), its pretty much over (except if you provide a library - written in C++, which then would provide Python with those abilities) - but then its getting really hacky…

Now, how could it be done:

When you are able to abstract all instructions - and provide an equivalent to any, you can basically translate it - even with a different syntax… - Programming languages always follow their Syntax, which makes translation possible (without the use of AI).

Now this might become a rather long example, but just to demonstrate you, how difficult it would be, even with a rather easy snippet of code - i’ll mostly be using Java throughout that demo:

Original C++ snippet:

#include <iostream> 
int n = 3; 
if (n > 0) { 
	std::cout << "n is positive" << "\n"; 
} 
std::cout << "Bye World!" << "\n";