diff --git a/c++.html.markdown b/c++.html.markdown
index f51d49c0..19946462 100644
--- a/c++.html.markdown
+++ b/c++.html.markdown
@@ -7,343 +7,344 @@ contributors:
lang: en
---
-I am writing this to highlight the differences and
-additions that C++ has with respect to C. My
+I am writing this to highlight the differences and
+additions that C++ has with respect to C. My
suggestion would be to follow the C tutorial first
then look here for the additions and differences.
```c++
-///////////////////////////////////////
-// C++ differences
-///////////////////////////////////////
-
-
-//In C++
-//cannot use void main()
-int main() { //or int main(int argc, char **argv)
- //cannot end with return;
- return 0;
- //Can also end without return statement
-}
-
-//In C++
-/*
- //This could lead to compiler errors and is discouraged
- //#if 0 #endif pairs are encouraged instead
-*/
-
-//In C++
-sizeof(10) //Typically 4
-sizeof('c') == 1
-
-//In C
-sizeof('c') == sizeof(10) //true chars are passed as ints
-
-
-//In C++ strict prototyping
-void func(); //function which accepts no arguments
-
-//In C
-void func(); //function which may accept arguments
-
-
-//In C++
-for(int i = 0; i < 10; i++) {;}
-//In C must int i must be declared before
-
-
-//C++ Supports Function overloading
-//Provided each function takes different
-//parameters
-
-void printing(char const *myString)
-{printf("String %s\n",myString);} //Hello
-
-void printing(int myInt)
-{printf("My int is %d",myInt);} //15
-
-int main ()
-{
- printing("Hello");
- printing(15);
-}
-
-
-
-//C++ Default Function Arguments
-void two_ints(int a = 1, int b = 4);
-
-int main()
-{
- two_ints(); // arguments: 1, 4
- two_ints(20); // arguments: 20, 4
- two_ints(20, 5); // arguments: 20, 5
-}
-
-
-//C++ added the nullptr which is different from 0
-int *ip = nullptr; // OK
-int value = nullptr; // error: value is no pointer
-
-
-///////////////////////////////////////
-// C++ Additions ontop of C
-///////////////////////////////////////
-
-
-///////////////////////////////////////
-// C++ Namespace
-///////////////////////////////////////
-
-//Namespaces allow you to define your own
-//functions and variables for use
-
-// Use '::' to change variable (or function) scope
-// Putting '::' before a function or variable will
-// reference a global scope
-
-// This allows you to make normal c library calls
-// std is for standard library
-using namespace std;
-
-#include
-
-int counter = 50; // global variable
-
-int main()
-{
- for (int counter = 1; // this refers to the
- counter < 2; // local variable
- counter++)
- {
- printf("Global var %d local var %d\n",
- ::counter, // global variable
- counter); // local variable
- // => Global var 50 local var 1
- }
-}
-
-// Namespaces can be nested
-
-
-namespace myFirstNameSpace
-{
- namespace myInnerSoul
- {
- cos(int x)
- {
- printf("My inner soul was made to program.");
- }
- }
-}
-
-namespace anotherNameSpace
-{
- cos(int x) {;} //does nothing
-}
-
-int main()
-{
- //Specify the full path because main is outside of both namespaces.
- //Will print out My inner soul was made to program.
- myFirstNameSpace::myInnerSoul::cos(60);
-}
-
-
-///////////////////////////////////////
-// C++ Strings
-///////////////////////////////////////
-
-//Strings in C++ are Objects and have many functions
-myString = "Hello";
-myOtherString = " World";
-
-myString + myOtherString; // => "Hello World"
-
-myString + ' You'; // => "Hello You"
-
-myString != myOtherString; //True
-
-//An example of a string method
-myString.append(" Dog"); // => "Hello Dog"
-
-
-///////////////////////////////////////
-// C++ Input Output
-///////////////////////////////////////
-
-//C++ input and output streams
-//cin, cout, cerr, << is insertion and >> is extraction operator
-#include
-
-using namespace std;
-
-int main()
-{
-
- int myInt;
-
- //Prints to stdout (or terminal/screen)
- cout << "Enter your fav number:\n";
- //Takes in input
- cin >> myInt;
-
- //cout can also be formatted
- cout << "Your fav number is " << myInt << "\n";
- //Your fav number is ##
-
- cerr << "Used for error messages";
-}
-
-
-///////////////////////////////////////
-// C++ Classes
+///////////////////////////////////////
+// C++ differences
///////////////////////////////////////
-//First example of classes
-#include
+//In C++
+//cannot use void main()
+int main() { //or int main(int argc, char **argv)
+ //cannot end with return;
+ return 0;
+ //Can also end without return statement
+}
-//define a class
-class Doggie
-{
- std::string name;
- int weight;
+//In C++
+/*
+ //This could lead to compiler errors and is discouraged
+ //#if 0 #endif pairs are encouraged instead
+*/
- // These are only the declarations
- //Can also have private and protected
- public:
- //The public methods (can also include variables)
+//In C++
+sizeof(10) //Typically 4
+sizeof('c') == 1
- // Default constructor
- Doggie();
-
- void setName(std::string dogsName);
- void setWeight(int dogsWeight);
- void printDog();
-
- //Can define functions within class declaration too
- void dogBark() {std::cout << "Bark Bark\n"}
-
- //Destructors are methods that free the allocated space
- ~doggieDestructor();
- //if no destructor compiler defines the trivial destructor
-
-//Classes are similar to structs and must close the } with ;
-};
-
-// This is the implementation of the class methods
-// Also called the definition
-void Doggie::Doggie () {
- std::cout << "A doggie is born. Woof!\n";
-}
-
-void Doggie::setName (std::string doggie_name) {
- name = doggie_name;
-}
-
-void Doggie::setWeight (int doggie_weight) {
- weight = doggie_weight;
-}
-
-void Doggie::printDog () {
- std::cout << "Dog is " << name << " weighs" << weight << "\n";
-}
-
-void Doggie::~doggieDestructor () {
- delete[] name;
- delete weight;
-}
-
-int main () {
- Doggie deedee; // prints out a doggie is born. Woof!
- deedee.setName ("Barkley");
- deedee.setWeight(1000000);
- deedee.printDog;
- //prints => Dog is Barkley weighs 1000000
- return 0;
-}
+//In C
+sizeof('c') == sizeof(10) //true chars are passed as ints
-//C++ Class inheritance
+//In C++ strict prototyping
+void func(); //function which accepts no arguments
-class German_Sheperd : public Doggie
+//In C
+void func(); //function which may accept arguments
+
+
+//In C++
+for(int i = 0; i < 10; i++) {;}
+//In C must int i must be declared before
+
+
+//C++ Supports Function overloading
+//Provided each function takes different
+//parameters
+
+void printing(char const *myString)
+{printf("String %s\n",myString);} //Hello
+
+void printing(int myInt)
+{printf("My int is %d",myInt);} //15
+
+int main ()
+{
+ printing("Hello");
+ printing(15);
+}
+
+
+
+//C++ Default Function Arguments
+void two_ints(int a = 1, int b = 4);
+
+int main()
+{
+ two_ints(); // arguments: 1, 4
+ two_ints(20); // arguments: 20, 4
+ two_ints(20, 5); // arguments: 20, 5
+}
+
+
+//C++ added the nullptr which is different from 0
+int *ip = nullptr; // OK
+int value = nullptr; // error: value is no pointer
+
+
+///////////////////////////////////////
+// C++ Additions ontop of C
+///////////////////////////////////////
+
+
+///////////////////////////////////////
+// C++ Namespace
+///////////////////////////////////////
+
+//Namespaces allow you to define your own
+//functions and variables for use
+
+// Use '::' to change variable (or function) scope
+// Putting '::' before a function or variable will
+// reference a global scope
+
+// This allows you to make normal c library calls
+// std is for standard library
+using namespace std;
+
+#include
+
+int counter = 50; // global variable
+
+int main()
+{
+ for (int counter = 1; // this refers to the
+ counter < 2; // local variable
+ counter++)
+ {
+ printf("Global var %d local var %d\n",
+ ::counter, // global variable
+ counter); // local variable
+ // => Global var 50 local var 1
+ }
+}
+
+// Namespaces can be nested
+
+
+namespace myFirstNameSpace
+{
+ namespace myInnerSoul
+ {
+ cos(int x)
+ {
+ printf("My inner soul was made to program.");
+ }
+ }
+}
+
+namespace anotherNameSpace
+{
+ cos(int x) {;} //does nothing
+}
+
+int main()
+{
+ //Specify the full path because main is outside of both namespaces.
+ //Will print out My inner soul was made to program.
+ myFirstNameSpace::myInnerSoul::cos(60);
+}
+
+
+///////////////////////////////////////
+// C++ Strings
+///////////////////////////////////////
+
+//Strings in C++ are Objects and have many functions
+myString = "Hello";
+myOtherString = " World";
+
+myString + myOtherString; // => "Hello World"
+
+myString + ' You'; // => "Hello You"
+
+myString != myOtherString; //True
+
+//An example of a string method
+myString.append(" Dog"); // => "Hello Dog"
+
+
+///////////////////////////////////////
+// C++ Input Output
+///////////////////////////////////////
+
+//C++ input and output streams
+//cin, cout, cerr, << is insertion and >> is extraction operator
+#include
+
+using namespace std;
+
+int main()
+{
+
+ int myInt;
+
+ //Prints to stdout (or terminal/screen)
+ cout << "Enter your fav number:\n";
+ //Takes in input
+ cin >> myInt;
+
+ //cout can also be formatted
+ cout << "Your fav number is " << myInt << "\n";
+ //Your fav number is ##
+
+ cerr << "Used for error messages";
+}
+
+
+///////////////////////////////////////
+// C++ Classes
+///////////////////////////////////////
+
+
+//First example of classes
+#include
+
+//define a class
+class Doggie
+{
+ std::string name;
+ int weight;
+
+ // These are only the declarations
+ //Can also have private and protected
+ public:
+ //The public methods (can also include variables)
+
+ // Default constructor
+ Doggie();
+
+ void setName(std::string dogsName);
+ void setWeight(int dogsWeight);
+ void printDog();
+
+ //Can define functions within class declaration too
+ void dogBark() {std::cout << "Bark Bark\n"}
+
+ //Destructors are methods that free the allocated space
+ ~doggieDestructor();
+ //if no destructor compiler defines the trivial destructor
+
+//Classes are similar to structs and must close the } with ;
+};
+
+// This is the implementation of the class methods
+// Also called the definition
+void Doggie::Doggie () {
+ std::cout << "A doggie is born. Woof!\n";
+}
+
+void Doggie::setName (std::string doggie_name) {
+ name = doggie_name;
+}
+
+void Doggie::setWeight (int doggie_weight) {
+ weight = doggie_weight;
+}
+
+void Doggie::printDog () {
+ std::cout << "Dog is " << name << " weighs" << weight << "\n";
+}
+
+void Doggie::~doggieDestructor () {
+ delete[] name;
+ delete weight;
+}
+
+int main () {
+ Doggie deedee; // prints out a doggie is born. Woof!
+ deedee.setName ("Barkley");
+ deedee.setWeight(1000000);
+ deedee.printDog;
+ //prints => Dog is Barkley weighs 1000000
+ return 0;
+}
+
+
+//C++ Class inheritance
+
+class German_Sheperd : public Doggie
{
//This class now inherits everything public and protected from Doggie class
- //Good practice to put d_ in front of datatypes in classes
- std::string d_type;
+ //Good practice to put d_ in front of datatypes in classes
+ std::string d_type;
- public:
- void dogType() {d_type = "German Sheperd";}
-};
+ public:
+ void dogType() {d_type = "German Sheperd";}
+};
-///////////////////////////////////////
-// C++ Exception Handling
-///////////////////////////////////////
+///////////////////////////////////////
+// C++ Exception Handling
+///////////////////////////////////////
-try {
- throw 12.25; // throws a double no handler declared
-} catch (int errorNum)
-{
- std::cout << "I caught an int " << errorNum << "\n";
-//default catcher
-} catch (...)
-{
- std::cout << "I got an error. Not sure what but I can pass it up.";
- throw;
-}
+try {
+ throw 12.25; // throws a double no handler declared
+} catch (int errorNum)
+{
+ std::cout << "I caught an int " << errorNum << "\n";
+//default catcher
+} catch (...)
+{
+ std::cout << "I got an error. Not sure what but I can pass it up.";
+ throw;
+}
-///////////////////////////////////////
-// C++ Operator Overloading
-///////////////////////////////////////
+///////////////////////////////////////
+// C++ Operator Overloading
+///////////////////////////////////////
-// In C++ you can overload operators such as +, -, new, etc.
+// In C++ you can overload operators such as +, -, new, etc.
-#include
-using namespace std;
+#include
+using namespace std;
-class Vector {
- public:
- double x,y;
- Vector () {};
- Vector (double a, double b) : x(a), y(b) {}
- Vector operator + (const CVector&);
- Vector operator += (const CVector&);
-};
-
-Vector Vector::operator+ (const Vector& rhs)
-{
- Vector temp;
- temp.x = x + rhs.x;
- temp.y = y + rhs.y;
- return temp;
-}
+class Vector {
+ public:
+ double x,y;
+ Vector () {};
+ Vector (double a, double b) : x(a), y(b) {}
+ Vector operator + (const CVector&);
+ Vector operator += (const CVector&);
+};
-Vector Vector::operator+= (const Vector& rhs)
-{
- x += rhs.x;
- y += rhs.y;
- return *this;
-}
+Vector Vector::operator+ (const Vector& rhs)
+{
+ Vector temp;
+ temp.x = x + rhs.x;
+ temp.y = y + rhs.y;
+ return temp;
+}
-int main () {
- Vector up (0,1);
- Vector right (1,0);
- Vector result;
- // This calls the Vector + operator
- // Vector up calls the + (function) with right as its paramater
- result = up + right;
- // prints out => Result is upright (1,1)
- cout << "Result is upright (" << result.x << ',' << result.y << ")\n";
- return 0;
+Vector Vector::operator+= (const Vector& rhs)
+{
+ x += rhs.x;
+ y += rhs.y;
+ return *this;
+}
+
+int main () {
+ Vector up (0,1);
+ Vector right (1,0);
+ Vector result;
+ // This calls the Vector + operator
+ // Vector up calls the + (function) with right as its paramater
+ result = up + right;
+ // prints out => Result is upright (1,1)
+ cout << "Result is upright (" << result.x << ',' << result.y << ")\n";
+ return 0;
}
```
-Futher Reading
+Futher Reading
-for more resources see: http://www.icce.rug.nl/documents/cplusplus/
-for other reference material: http://www.cplusplus.com/doc/tutorial/
+for more resources see: http://www.icce.rug.nl/documents/cplusplus/
+
+for other reference material: http://www.cplusplus.com/doc/tutorial/