user693: What are the advantages of each language when using the Arduino?
I'm thinking this is a good general question, but I'll add a bit about why I'm asking if anyone wants to give me a tip.
I'm experienced in preprocessed languages like JavaScript, PHP, and have fiddled with languages like Java and Visual Basic. In other words I know programming techniques and both classical and prototypal object orientation, but nothing about communicating directly with hardware.
I'm making an octocopter, and am thinking that an object oriented approach will be the easiest. (The software will have very many features...) However I have never written in C++.
Since this is a Q&A site that's supposed to help others, only the general question presented at the beginning is of much importance, but I'd appreciate any comments on my situation.

user7727: The Arduino language is C++ (albeit usually implemented in a style more like "C with classes," which is actually fairly common in the embedded systems microcontroller world). End of story. Enough with people thinking it's a different language already! It uses the g++ compiler. 
Proof:
Enable verbose output during compilation in the Preferences and upload and you'll learn a lot just reading those lines. 
Here's some additional insight:
My own words:
Arduino code is C++. The Arduino core functions are simply a set of C++ classes and libraries you can use. It is built and compiled using the GNU gcc/g++ compiler. Your setup() and loop() functions are simply placed into the mandatory main() function (right here actually--notice the file is "main.cpp", which is a C++ source file) automatically for you and there is some extra preprocessing done to make sure it is a valid C++ program (ex: scanning for all function prototypes [aka: declarations] for you so you can use a function even though its prototype comes later in your .ino file). Much of Arduino is written in a "C style", however, and therefore requires the # extern "C" {} braces around it to prevent C++ from "name-mangling" (also known as "name decorating/name decoration") function calls to C functions implemented by AVR-libc, which is the C implementation for the ATmega328 and other AVR-architecture microcontrollers.
Arduino's words:

"Can I program the Arduino board in C?
  In fact, you already are; the Arduino language is merely a set of C/C++ functions that can be called from your code. Your sketch undergoes minor changes (e.g. automatic generation of function prototypes) and then is passed directly to a C/C++ compiler (avr-g++). All standard C and C++ constructs supported by avr-g++ should work in Arduino. For more details, see the page on the Arduino build process."  

Source: https://www.arduino.cc/en/Main/FAQ#toc13
When to use the Arduino library vs pure C or C++?
So, use the Arduino language where it simplifies things, and write your own functions where you need more specialization. I do recommend getting away from the IDE quickly though for writing code--just use it for compilation. Set the IDE preferences to use "External Editor." Then use a professional source code editor/IDE such as Sublime Text 3, Atom, Visual Studio Code, or Eclipse CDT to write your code. You can then click back to the Arduino IDE to compile and upload. If you go with Eclipse, there are ways to do that in Eclipse (see the other answers here, and see the Arduino playground Eclipse article here too) so consider using those techniques too. 
Update: Eclipse setup
See my answer here: What are the other IDEs for Arduino?. I wrote a detailed PDF to describe setup.

user8616: In addition to the comments above, I would like to further stress the problems with working RAM that you have on Arduino boards, particularly with the Uno (and others that share the same microcontroller).  I recently wrote a simple Space Invaders game running on a 32x32 LED matrix and repeatedly ran into problems caused by low memory.
The Uno only has 2048 bytes of RAM.  The library for my matrix took over 3/4 of that leaving me with around 400 bytes for the game.  As it is my intention to "upgrade" the project at some point to run multiple games with the same program base on the more powerful Due, I designed the code with OO principals and a lot of class inheritance.  (The game class was inherited with virtual update and draw calls, the game entities were all inherited).
I pretty much ran out of memory just adding the invaders.  I tried to save memory by bit-fielding their member variables but ran out again when adding the shield objects.  After a bit more scraping I ran out adding the bombs/bullets.  At this point I scoured the code and removed all "virtual" tags (all my class prototypes are built from a Visual Assist snippet and destructors are all virtual automatically).  This halved my memory usage instantly, freeing enough to be able to complete the code.
Long story short, the end result is C++ code that doesn't really use any C++ features.  You might be as well just sticking to C and being very aware of your memory usage.  You get no help if you exceed the 2KB - particularly if you are using any dynamic allocation, the code just stops working and you are left scratching your head for a while until you consider the possibility of memory overflow.
PS - Bit fielding variables is bad.  Very bad.  Apart from adding processing overhead, I lost track of the number of times I'd add a new state to the game but the code wouldn't run and I couldn't understand why.  My state variable was not wide enough to hold the new state value so I was getting some unexpected state.

user7978: As mentioned in several answers, if you are programing an embedded system in general you should avoid new unless you are managing your own memory heap and you really know what your object life cycles will be. Static allocation or stack variables are much safer. That said, one common trick to manage things like variable length buffers allocated for the duration of a function is to have an automatic variable (on the stack) that is an object that calls new in its constructor, and then put the delete in the destructor so when the object goes out of scope the buffer is released back to the heap. Again, this is usually of limited use in little micros but it is a nice pattern to remember.

user881: In my experience, it is best to avoid new and delete when running on machines with limited memory. 

The memory management itself uses valuable program and RAM space
ISR vectors are set at compile tme. It is difficult (impossible?) for a class instance to claim an ISR at run time
Generally you will know at compile time what class instances you need - e.g. 3 button debouncers, a display driver and a 2-line display driver
Memory management introduces unknown delays when you use new or delete.

There may be cases where it is justified to use dynamic instance construction and destruction, but I suspect they are rare. 

user8: The Arduino language is C++, but it is very different from most C++ varieties. The Arduino language has a lot of abstraction built in, especially in the hardware interfaces, which makes it very simple to use. If you have a background in Java, C and C++ should be very similar.
The main differences between Arduino and C++ are in the memory storage. Usually a modern computer has more than 2GB of RAM, while the Arduino Uno has 2kB (1 million times less). The Arduino also uses 8-bit instructions in stead of the 32 bit ones a computer uses. This will mainly affect the amount of information you can store in a variable.
If you are very new to the Arduino world, you should look up a tutorial, as there are many good ones out there.

user313: --- Update 170412
I wrote my original answer three years ago from the perspective of there existing a distinct "Arduino C++". The language used in the IDE is standard C++, because it is implemented by the GNU C++ compiler. "Apparent" differences creep in because the IDE will do some pre-processing to help newcomers to the language avoid a couple of 'gotcha's, by filling in some #includes, f/ex. But you can - and I do - write correct C++ to it and get just what you expect to get.
--- end update 
Do limit your use of C++ language features to those whose implementation you fully understand. There are some features that compile to more resource-intensive code than is obvious from reading the source code. The optionally generated .lss (merged source and assembly) listing can give you some good insight into what the C++ compiler did when you weren't looking.
To your question about memory: C++ does not garbage-collect. Stack-based languages like C and C++ do allocate temporary storage on the stack for automatic variables at function entry, which then gets released when the function returns, but this is not true garbage-collection. Objects created in heap- or global memory live until you explicitly delete them. Make sure you know where, when, and for how long different kinds of objects will be created. You really don't want your code new-ing and delete-ing objects willy-nilly. They will be built in heap memory, fragmenting it and causing it to grow up into the stack. That's when your code - and your nice 'copter - will crash.
C does less for you so it can do less to you. It's not a bad choice. C with a few of C++'s features can be an even better choice, given you choose the extra features judiciously.C++, if those are your two choices:
[Original answer]
 - C++ is a standardized language. It is widely deployed in many environments including embedded systems and therefore is more thoroughly tested than the very-like-C++ language that is "Arduino". This is especially important for mission-critical / safety-critical applications such as you are planning. Crashed code means a crashed 'copter and even if it doesn't hurt someone, it will break your expensive machine.

Being standard, C++ is portable. Need to upgrade your processor? Everything but silicon-specific code will port to the new one. Need to change your toolset, development system, host OS? C++ will be supported everywhere. Though Arduino IDE will run anywhere Java is supported, it is the only tool that uses Arduino C++ and it is a very limited tool. If you want to use Eclipse, the AVR tools, go barefoot on the command-line, develop within Emacs, or whatever other environment you prefer, standard C++ will be supported.
The Arduino IDE does things behind your back - specifically, it #includes .h files when it thinks you need them. Even if it is correct, you really want to write, or at least see and understand, everything the compiler is going to see. Programming languages aren't made for computers (computers eat bits for breakfast); they're made for people, specifically the people who follow you on the project, the most important of whom may be ... you!, when 6 months after you wrote a module, you have to come back to enhance it, or more likely, fix it. You really want to be able to see everything the compiler sees.


user349: 
What are the advantages of C++ vs the Arduino language when using Arduino? I'm experienced in preprocessed languages like JavaScript, PHP, and have fiddled with languages like Java and Visual Basic.

First, the Arduino compiler/IDE accepts C and C++ as-is.  In fact many of the libraries are written in C++.  Much of the underlying system is not object oriented, but it could be.
Thus, "The arduino language" is C++ or C.
C++ is not garbage collected.  It does manage variables in scope - if you write:
int led = 13;

void blinkTimes(int value)
{
   int i;

   for(i=0;i<value;i++)
   {
      digitalWrite(led, HIGH);
      delay(1000);
      digitalWrite(led, LOW);
      delay(1000);
   }
}

Then you'll find that led and i don't grow or leak, no matter how many times you call blinkTimes.
If i were a class, it would similarly be disposed of once the function ended.  So as long as you aren't using new or similar memory allocation functions to create new objects, then you won't have to worry about leaks.
You may still run out of memory, if you create huge classes and use a lot of them in deeply nested functions, but in general you aren't going to run into trouble until you start dealing with new and free functions.
If you are using new, then you'll have to call delete at appropriate times.  C++, and by extension Arduino, has no automatic garbage collection, you have to explicitly manage your own memory.

user42: In theory...
There isn't really an Arduino language as such. It's really just C++ with some domain-specific libraries. These add on various features, such as functions you can call to control the hardware. If you didn't have those functions, you'd need to fiddle directly with special registers to control everything. That's how embedded programming is usually done. It's fast, but it can be quite hard to learn and understand.
In addition to the functions, the libraries add alternative names for some types. For example, boolean and byte are not in the C++ standard. However, they are directly equivalent to bool and unsigned char.
All of these things mean you can probably port general C++ code directly to Arduino without difficulty. However, going back the other way may require some minor editing.
In practice...
Having said all of that, programming for Arduino isn't exactly the same as general C++ programming. A lot of the differences are common to all embedded programming though (such as limited memory and processing power).
It's also worth noting that if you're using the official Arduino IDE then there are all sorts of annoying quirks and limitations on how you setup your code. There are workarounds in all cases (as far as I'm aware), but they are sometimes quite frustrating.
For full flexibility, use a third-party IDE (such as Eclipse) with a plug-in to support Arduino. That should give you all the advantages of C++, along with the Arduino libraries.

user666: My personal experience as professor (programming, mechatronics) is that if you have previous programming experience and you are aware of concepts as OOP, it is better to go for C/C++. The arduino language is really great for beginners, but have some limitations (e.g. you must have all your files in the same folder). And it is basically a simplification of C/C++ (you can practically copy&paste arduino code to a C/C++ file, and it will work). Also it makes sense that you can go and use a full well known IDE as eclipse:
http://playground.arduino.cc/Code/Eclipse
Initially it is required a bit more of setup and configuration of your dev environment, but IMHO it is worth it for programmers with experience in any other language.
In any case, it won't harm you to start using the arduino language and the arduino IDE for a few days to get familiar with the arduino hardware and then move to C/C++ with Eclipse for really developing your project.

693: <p>What are the advantages of each language when using the Arduino?</p>

<p>I'm thinking this is a good general question, but I'll add a bit about why I'm asking if anyone wants to give me a tip.</p>

<p>I'm experienced in preprocessed languages like JavaScript, PHP, and have fiddled with languages like Java and Visual Basic. In other words I know programming techniques and both classical and prototypal object orientation, but nothing about communicating directly with hardware.</p>

<p>I'm making an octocopter, and am thinking that an object oriented approach will be the easiest. (The software will have very many features...) However I have never written in C++.</p>

<p>Since this is a Q&amp;A site that's supposed to help others, only the general question presented at the beginning is of much importance, but I'd appreciate any comments on my situation.</p>
 7727: <p><strong>The Arduino language <em>is</em> C++</strong> (albeit usually implemented in a style more like "C with classes," which is actually fairly common in the embedded systems microcontroller world). <strong>End of story.</strong> Enough with people thinking it's a different language already! It uses the g++ compiler. </p>

<h2>Proof:</h2>

<p><strong>Enable verbose output during compilation in the Preferences and upload and you'll learn a lot just reading those lines.</strong> </p>

<h2>Here's some additional insight:</h2>

<h3>My own words:</h3>

<p><strong>Arduino code <em>is</em> C++.</strong> The Arduino <a href="https://www.arduino.cc/reference/en/" rel="nofollow noreferrer">core functions</a> are simply a set of C++ classes and libraries you can use. It is built and compiled using the <a href="https://en.wikipedia.org/wiki/GNU_Compiler_Collection" rel="nofollow noreferrer">GNU gcc/g++ compiler</a>. Your setup() and loop() functions are simply placed into the mandatory main() function (<a href="https://github.com/arduino/Arduino/blob/master/hardware/arduino/avr/cores/arduino/main.cpp" rel="nofollow noreferrer">right here actually</a>--notice the file is "main.cpp", which is a C++ source file) automatically for you and there is some extra preprocessing done to make sure it is a valid C++ program (ex: scanning for all function prototypes [aka: declarations] for you so you can use a function even though its prototype comes later in your .ino file). Much of Arduino is written in a "C style", however, and therefore requires the <code># extern "C" {}</code> braces around it to prevent C++ from <a href="https://www.geeksforgeeks.org/extern-c-in-c/" rel="nofollow noreferrer">"name-mangling"</a> (also known as <a href="https://en.wikipedia.org/wiki/Name_mangling" rel="nofollow noreferrer">"name decorating/name decoration"</a>) function calls to C functions implemented by <a href="https://www.nongnu.org/avr-libc/" rel="nofollow noreferrer">AVR-libc</a>, which is the C implementation for the ATmega328 and other <a href="https://en.wikipedia.org/wiki/Atmel_AVR" rel="nofollow noreferrer">AVR-architecture</a> microcontrollers.</p>

<h3>Arduino's words:</h3>

<blockquote>
  <p>"<a href="https://www.arduino.cc/en/Main/FAQ#toc13" rel="nofollow noreferrer">Can I program the Arduino board in C?</a><br>
  In fact, you already are; the Arduino language is merely a set of C/C++ functions that can be called from your code. Your sketch undergoes minor changes (e.g. automatic generation of function prototypes) and then is passed directly to a C/C++ compiler (avr-g++). All standard C and C++ constructs <a href="https://www.nongnu.org/avr-libc/user-manual/FAQ.html#faq_cplusplus" rel="nofollow noreferrer">supported by avr-g++</a> should work in Arduino. For more details, see the page on the <a href="https://www.arduino.cc/en/Hacking/BuildProcess" rel="nofollow noreferrer">Arduino build process</a>."  </p>
</blockquote>

<p>Source: <a href="https://www.arduino.cc/en/Main/FAQ#toc13" rel="nofollow noreferrer">https://www.arduino.cc/en/Main/FAQ#toc13</a></p>

<h2>When to use the <a href="https://www.arduino.cc/reference/en/" rel="nofollow noreferrer">Arduino library</a> vs pure C or C++?</h2>

<p>So, use the Arduino language where it simplifies things, and write your own functions where you need more specialization. I do recommend getting away from the IDE quickly though for writing code--just use it for compilation. Set the IDE preferences to use "External Editor." Then use a professional source code editor/IDE such as <a href="https://www.sublimetext.com/3" rel="nofollow noreferrer">Sublime Text 3</a>, <a href="https://atom.io/" rel="nofollow noreferrer">Atom</a>, <a href="https://code.visualstudio.com/" rel="nofollow noreferrer">Visual Studio Code</a>, or <a href="https://www.eclipse.org/cdt/" rel="nofollow noreferrer">Eclipse CDT</a> to write your code. You can then click back to the Arduino IDE to compile and upload. If you go with Eclipse, there are ways to do that in Eclipse (see the other answers here, and see the <a href="http://playground.arduino.cc/Code/Eclipse" rel="nofollow noreferrer">Arduino playground Eclipse article</a> here too) so consider using those techniques too. </p>

<h1>Update: Eclipse setup</h1>

<p>See my answer here: <a href="https://arduino.stackexchange.com/questions/40/what-are-the-other-ides-for-arduino/75491#75491">What are the other IDEs for Arduino?</a>. I wrote a detailed PDF to describe setup.</p>
 8616: <p>In addition to the comments above, I would like to further stress the problems with working RAM that you have on Arduino boards, particularly with the Uno (and others that share the same microcontroller).  I recently wrote a simple Space Invaders game running on a 32x32 LED matrix and repeatedly ran into problems caused by low memory.</p>

<p>The Uno only has 2048 bytes of RAM.  The library for my matrix took over 3/4 of that leaving me with around 400 bytes for the game.  As it is my intention to "upgrade" the project at some point to run multiple games with the same program base on the more powerful Due, I designed the code with OO principals and a lot of class inheritance.  (The game class was inherited with virtual update and draw calls, the game entities were all inherited).</p>

<p>I pretty much ran out of memory just adding the invaders.  I tried to save memory by bit-fielding their member variables but ran out again when adding the shield objects.  After a bit more scraping I ran out adding the bombs/bullets.  At this point I scoured the code and removed all "virtual" tags (all my class prototypes are built from a Visual Assist snippet and destructors are all virtual automatically).  This halved my memory usage instantly, freeing enough to be able to complete the code.</p>

<p>Long story short, the end result is C++ code that doesn't really use any C++ features.  You might be as well just sticking to C and being very aware of your memory usage.  You get no help if you exceed the 2KB - particularly if you are using any dynamic allocation, the code just stops working and you are left scratching your head for a while until you consider the possibility of memory overflow.</p>

<p>PS - Bit fielding variables is bad.  Very bad.  Apart from adding processing overhead, I lost track of the number of times I'd add a new state to the game but the code wouldn't run and I couldn't understand why.  My state variable was not wide enough to hold the new state value so I was getting some unexpected state.</p>
 7978: <p>As mentioned in several answers, if you are programing an embedded system in general you should avoid <strong>new</strong> unless you are managing your own memory heap and you really know what your object life cycles will be. Static allocation or stack variables are much safer. That said, one common trick to manage things like variable length buffers allocated for the duration of a function is to have an automatic variable (on the stack) that is an object that calls <strong>new</strong> in its constructor, and then put the <strong>delete</strong> in the destructor so when the object goes out of scope the buffer is released back to the heap. Again, this is usually of limited use in little micros but it is a nice pattern to remember.</p>
 881: <p>In my experience, it is best to avoid <b>new</b> and <b>delete</b> when running on machines with limited memory. </p>

<ul>
  <li>The memory management itself uses valuable program and RAM space</li>
  <li>ISR vectors are set at compile tme. It is difficult (impossible?) for a class instance to claim an ISR at run time</li>
  <li>Generally you will know at compile time what class instances you need - e.g. 3 button debouncers, a display driver and a 2-line display driver</li>
  <li>Memory management introduces unknown delays when you use new or delete.
</ul>

<p>There may be cases where it is justified to use dynamic instance construction and destruction, but I suspect they are rare. </p>
 8: <p>The Arduino language <em>is</em> C++, but it is very different from most C++ varieties. The Arduino language has a lot of abstraction built in, especially in the hardware interfaces, which makes it very simple to use. If you have a background in Java, C and C++ should be very similar.</p>

<p>The main differences between Arduino and C++ are in the memory storage. Usually a modern computer has more than 2GB of RAM, while the Arduino Uno has 2kB (1 million times less). The Arduino also uses 8-bit instructions in stead of the 32 bit ones a computer uses. This will mainly affect the amount of information you can store in a variable.</p>

<p>If you are very new to the Arduino world, you should look up a tutorial, as there are many good ones out there.</p>
 313: <p>--- Update 170412<br>
I wrote my original answer three years ago from the perspective of there existing a distinct "Arduino C++". The language used in the IDE <em>is</em> standard C++, because it is implemented by the GNU C++ compiler. "Apparent" differences creep in because the IDE will do some pre-processing to help newcomers to the language avoid a couple of 'gotcha's, by filling in some #includes, f/ex. But you can - and I do - write correct C++ to it and get just what you expect to get.<br>
--- end update </p>

<p>Do limit your use of C++ language features to those whose implementation you fully understand. There are some features that compile to more resource-intensive code than is obvious from reading the source code. The optionally generated .lss (merged source and assembly) listing can give you some good insight into what the C++ compiler did when you weren't looking.</p>

<p>To your question about memory: C++ does not garbage-collect. Stack-based languages like C and C++ do allocate temporary storage on the stack for automatic variables at function entry, which then gets released when the function returns, but this is not true garbage-collection. Objects created in heap- or global memory live until you explicitly delete them. Make sure you know where, when, and for how long different kinds of objects will be created. You really don't want your code <code>new</code>-ing and <code>delete</code>-ing objects willy-nilly. They will be built in heap memory, fragmenting it and causing it to grow up into the stack. That's when your code - and your nice 'copter - will crash.</p>

<p>C does less for you so it can do less <strong>to</strong> you. It's not a bad choice. C with a few of C++'s features can be an even better choice, given you choose the extra features judiciously.C++, if those are your two choices:</p>

<p>[Original answer]
 - C++ is a standardized language. It is widely deployed in many environments including embedded systems and therefore is more thoroughly tested than the very-like-C++ language that is "Arduino". This is especially important for mission-critical / safety-critical applications such as you are planning. Crashed code means a crashed 'copter and even if it doesn't hurt someone, it <strong>will</strong> break your expensive machine.</p>

<ul>
<li><p>Being standard, C++ is portable. Need to upgrade your processor? Everything but silicon-specific code will port to the new one. Need to change your toolset, development system, host OS? C++ will be supported everywhere. Though Arduino IDE will run anywhere Java is supported, it is the only tool that uses Arduino C++ and it is a very limited tool. If you want to use Eclipse, the AVR tools, go barefoot on the command-line, develop within Emacs, or whatever other environment you prefer, standard C++ will be supported.</p></li>
<li><p>The Arduino IDE does things behind your back - specifically, it #includes .h files when it thinks you need them. Even if it is correct, you really want to write, or at least see and understand, everything the compiler is going to see. Programming languages aren't made for computers (computers eat bits for breakfast); they're made for people, specifically the people who follow you on the project, the most important of whom may be ... you!, when 6 months after you wrote a module, you have to come back to enhance it, or more likely, fix it. You really want to be able to see everything the compiler sees.</p></li>
</ul>
 349: <blockquote>
  <p>What are the advantages of C++ vs the Arduino language when using Arduino? I'm experienced in preprocessed languages like JavaScript, PHP, and have fiddled with languages like Java and Visual Basic.</p>
</blockquote>

<p>First, the Arduino compiler/IDE accepts C and C++ as-is.  In fact many of the libraries are written in C++.  Much of the underlying system is not object oriented, but it could be.</p>

<p>Thus, "The arduino language" is C++ or C.</p>

<p>C++ is not garbage collected.  It does manage variables in scope - if you write:</p>

<pre><code>int led = 13;

void blinkTimes(int value)
{
   int i;

   for(i=0;i&lt;value;i++)
   {
      digitalWrite(led, HIGH);
      delay(1000);
      digitalWrite(led, LOW);
      delay(1000);
   }
}
</code></pre>

<p>Then you'll find that <code>led</code> and <code>i</code> don't grow or leak, no matter how many times you call <code>blinkTimes</code>.</p>

<p>If <code>i</code> were a class, it would similarly be disposed of once the function ended.  So as long as you aren't using <code>new</code> or similar memory allocation functions to create new objects, then you won't have to worry about leaks.</p>

<p>You may still run out of memory, if you create huge classes and use a lot of them in deeply nested functions, but in general you aren't going to run into trouble until you start dealing with <code>new</code> and <code>free</code> functions.</p>

<p>If you are using <code>new</code>, then you'll have to call <code>delete</code> at appropriate times.  C++, and by extension Arduino, has no automatic garbage collection, you have to explicitly manage your own memory.</p>
 42: <p><strong>In theory...</strong><br>
There isn't really an Arduino language as such. It's really just C++ with some domain-specific libraries. These add on various features, such as functions you can call to control the hardware. If you didn't have those functions, you'd need to fiddle directly with special registers to control everything. That's how embedded programming is usually done. It's fast, but it can be quite hard to learn and understand.</p>

<p>In addition to the functions, the libraries add alternative names for some types. For example, <code>boolean</code> and <code>byte</code> are not in the C++ standard. However, they are directly equivalent to <code>bool</code> and <code>unsigned char</code>.</p>

<p>All of these things mean you can probably port general C++ code directly to Arduino without difficulty. However, going back the other way may require some minor editing.</p>

<p><strong>In practice...</strong><br>
Having said all of that, programming for Arduino isn't exactly the same as general C++ programming. A lot of the differences are common to all embedded programming though (such as limited memory and processing power).</p>

<p>It's also worth noting that if you're using the official Arduino IDE then there are all sorts of annoying quirks and limitations on how you setup your code. There are workarounds in all cases (as far as I'm aware), but they are sometimes quite frustrating.</p>

<p>For full flexibility, use a third-party IDE (such as Eclipse) with a plug-in to support Arduino. That should give you all the advantages of C++, along with the Arduino libraries.</p>
 666: <p>My personal experience as professor (programming, mechatronics) is that if you have previous programming experience and you are aware of concepts as OOP, it is better to go for C/C++. The arduino language is really great for beginners, but have some limitations (e.g. you must have all your files in the same folder). And it is basically a simplification of C/C++ (you can practically copy&amp;paste arduino code to a C/C++ file, and it will work). Also it makes sense that you can go and use a full well known IDE as eclipse:</p>

<p><a href="http://playground.arduino.cc/Code/Eclipse">http://playground.arduino.cc/Code/Eclipse</a></p>

<p>Initially it is required a bit more of setup and configuration of your dev environment, but IMHO it is worth it for programmers with experience in any other language.</p>

<p>In any case, it won't harm you to start using the arduino language and the arduino IDE for a few days to get familiar with the arduino hardware and then move to C/C++ with Eclipse for really developing your project.</p>
