learnxinyminutes-docs/c++.html.markdown

---
language: c++
filename: learncpp.cpp
contributors:
    - ["Steven Basart", "http://github.com/xksteven"]
    - ["Matt Kline", "https://github.com/mrkline"]
lang: en
---

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 <stdio.h>

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 <iostream>

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 <iostream>

//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;

   public:
      void dogType() {d_type = "German Sheperd";}
};



///////////////////////////////////////
// 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;
}


///////////////////////////////////////
// C++ Operator Overloading
///////////////////////////////////////

// In C++ you can overload operators such as +, -, new, etc.

#include <iostream>
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;
}

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

for more resources see: http://www.icce.rug.nl/documents/cplusplus/

for other reference material: http://www.cplusplus.com/doc/tutorial/