diff options
Diffstat (limited to 'c++.html.markdown')
| -rw-r--r-- | c++.html.markdown | 527 |
1 files changed, 305 insertions, 222 deletions
diff --git a/c++.html.markdown b/c++.html.markdown index 19946462..ce2d2d65 100644 --- a/c++.html.markdown +++ b/c++.html.markdown @@ -7,323 +7,381 @@ contributors: 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++ was designed as a systems programming language that + +- is a "better C" +- supports data abstraction +- supports object-oriented programming +- supports generic programming + +Though its syntax can be more difficult or complex than newer languages, +it is widely used because it compiles to native instructions that can be +directly run by the processor and offers tight control over hardware (like C) +while offering high-level features such as generics, exceptions, and classes. +This combination of speed and functionality makes C++ +one of the most widely-used programming languages. ```c++ -/////////////////////////////////////// -// C++ differences -/////////////////////////////////////// +////////////////// +// Comparison to C +////////////////// +// C++ is _almost_ a superset of C and shares its basic syntax for +// variable declarations, primitive types, and functions. +// However, C++ varies in some of the following ways: -//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 +// A main() function in C++ should return an int, +// though void main() is accepted by most compilers (gcc, clang, etc.) +int main() // or int main(int argc, char** argv) +{ + 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 +// In C++, character literals are one byte. sizeof('c') == 1 -//In C -sizeof('c') == sizeof(10) //true chars are passed as ints - +// In C, character literals are the same size as ints. +sizeof('c') == sizeof(10) -//In C++ strict prototyping -void func(); //function which accepts no arguments -//In C -void func(); //function which may accept arguments +// C++ has strict prototyping +void func(); // function which accepts no arguments +// In C +void func(); // function which may accept any number of arguments -//In C++ -for(int i = 0; i < 10; i++) {;} -//In C must int i must be declared before +// Use nullptr instead of NULL in C++ +int* ip = nullptr; +// C standard headers are available in C++, +// but are prefixed with "c" and have no .h suffix. +#include <cstdio> -//C++ Supports Function overloading -//Provided each function takes different -//parameters +int main() +{ + printf("Hello, world!\n"); + return 0; +} -void printing(char const *myString) -{printf("String %s\n",myString);} //Hello +/////////////////////// +// Function overloading +/////////////////////// -void printing(int myInt) -{printf("My int is %d",myInt);} //15 +// C++ supports function overloading +// provided each function takes different parameters. -int main () +void print(char const* myString) { - printing("Hello"); - printing(15); + printf("String %s\n", myString); } - - -//C++ Default Function Arguments -void two_ints(int a = 1, int b = 4); +void print(int myInt) +{ + printf("My int is %d", myInt); +} int main() { - two_ints(); // arguments: 1, 4 - two_ints(20); // arguments: 20, 4 - two_ints(20, 5); // arguments: 20, 5 + printing("Hello"); // Resolves to void print(const char*) + printing(15); // Resolves to void print(int) } +///////////////////////////// +// Default function arguments +///////////////////////////// -//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 +void two_ints(int a = 1, int b = 4); 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 - } + two_ints(); // a = 1, b = 4 + two_ints(20); // a = 20, b = 4 + two_ints(20, 5); // a = 20, b = 5 } -// Namespaces can be nested +///////////// +// Namespaces +///////////// -namespace myFirstNameSpace -{ - namespace myInnerSoul - { - cos(int x) +// Namespaces provide separate scopes for variable, function, +// and other declarations. +// Namespaces can be nested + +namespace First { + namespace Nested { + void foo() { - printf("My inner soul was made to program."); + printf("This is First::Nested::foo\n"); } + } // end namespace Nested +} // end namespace First + +namespace Second { + void foo() + { + printf("This is Second::foo\n") } } -namespace anotherNameSpace +void foo() { - cos(int x) {;} //does nothing + printf("This is global foo\n"); } 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"; + // Assume everything is from the namespace "Second" + // unless otherwise specified. + using namespace Second; -myString + myOtherString; // => "Hello World" - -myString + ' You'; // => "Hello You" - -myString != myOtherString; //True - -//An example of a string method -myString.append(" Dog"); // => "Hello Dog" + foo(); // prints "This is Second::foo" + First::Nested::foo(); // prints "This is First::Nested::foo" + ::foo(); // prints "This is global foo" +} +/////////////// +// Input/Output +/////////////// -/////////////////////////////////////// -// C++ Input Output -/////////////////////////////////////// +// C++ input and output uses streams +// cin, cout, and cerr represent stdin, stdout, and stderr. +// << is the insertion operator and >> is the extraction operator. -//C++ input and output streams -//cin, cout, cerr, << is insertion and >> is extraction operator -#include <iostream> +#include <iostream> // Include for I/O streams using namespace std; int main() { - int myInt; - //Prints to stdout (or terminal/screen) + // Prints to stdout (or terminal/screen) cout << "Enter your fav number:\n"; - //Takes in input + // Takes in input cin >> myInt; - //cout can also be formatted + // cout can also be formatted cout << "Your fav number is " << myInt << "\n"; - //Your fav number is ## + // Your fav number is ## - cerr << "Used for error messages"; + cerr << "Used for error messages"; } +////////// +// Strings +////////// -/////////////////////////////////////// -// C++ Classes -/////////////////////////////////////// +// Strings in C++ are objects and have many member functions +#include <string> +using namespace std; // Strings are in the namespace std (standard library) -//First example of classes -#include <iostream> +string myString = "Hello"; +string myOtherString = " World"; -//define a class -class Doggie -{ - std::string name; - int weight; +// + is used for concatenation. +cout << myString + myOtherString; // "Hello World" - // These are only the declarations - //Can also have private and protected - public: - //The public methods (can also include variables) +cout << myString + " You"; // "Hello You" - // Default constructor - Doggie(); +// C++ strings are mutable and have value semantics. +myString.append(" Dog"); +cout << myString; // "Hello Dog" - 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"} +///////////// +// References +///////////// - //Destructors are methods that free the allocated space - ~doggieDestructor(); - //if no destructor compiler defines the trivial destructor +// In addition to pointers like the ones in C, +// C++ has _references_. +// These are pointer types that cannot be reassigned once set +// and cannot be null. +// They also have the same syntax as the variable itself: +// No * is needed for dereferencing and +// & (address of) is not used for assignment. -//Classes are similar to structs and must close the } with ; -}; +using namespace std; + +string foo = "I am foo"; +string bar = "I am bar"; + + +string& fooRef = foo; // This creates a reference to foo. +fooRef += ". Hi!"; // Modifies foo through the reference +cout << foo; // Prints "I am foo. Hi!" + +fooRef = bar; // Error: references cannot be reassigned. + +const string& barRef = bar; // Create a const reference to bar. +// Like C, const values (and pointers and references) cannot be modified. +barRef += ". Hi!"; // Error, const references cannot be modified. -// This is the implementation of the class methods -// Also called the definition -void Doggie::Doggie () { - std::cout << "A doggie is born. Woof!\n"; +////////////////////////////////////////// +// Classes and object-oriented programming +////////////////////////////////////////// + +// First example of classes +#include <iostream> + +// Declare a class. +// Classes are usually declared in header (.h or .hpp) files. +class Dog { + // Member variables and functions are private by default. + std::string name; + int weight; + +// All members following this are public +// until "private:" or "protected:" is found. +public: + + // Default constructor + Dog(); + + // Member function declarations (implementations to follow) + // Note that we use std::string here instead of placing + // using namespace std; + // above. + // Never put a "using namespace" statement in a header. + void setName(const std::string& dogsName); + + void setWeight(int dogsWeight); + + // Functions that do not modify the state of the object + // should be marked as const. + // This allows you to call them if given a const reference to the object. + // Also note the functions must be explicitly declared as _virtual_ + // in order to be overridden in derived classes. + // Functions are not virtual by default for performance reasons. + virtual void print() const; + + // Functions can also be defined inside the class body. + // Functions defined as such are automatically inlined. + void bark() const { std::cout << name << " barks!\n" } + + // Along with constructors, C++ provides destructors. + // These are called when an object is deleted or falls out of scope. + // This enables powerful paradigms such as RAII + // (http://en.wikipedia.org/wiki/Resource_Acquisition_Is_Initialization) + // Destructors must be virtual to allow classes to be derived from this one. + virtual ~Dog(); + +}; // A semicolon must follow the class definition. + +// Class member functions are usually implemented in .cpp files. +void Dog::Dog() +{ + std::cout << "A dog has been constructed\n"; } -void Doggie::setName (std::string doggie_name) { +// Objects (such as strings) should be passed by reference +// if you are modifying them or const reference if you are not. +void Dog::setName(const std::string& dogsName) +{ name = doggie_name; } -void Doggie::setWeight (int doggie_weight) { - weight = doggie_weight; +void Dog::setWeight(int dogsWeight) +{ + weight = dogsWeight; } -void Doggie::printDog () { - std::cout << "Dog is " << name << " weighs" << weight << "\n"; +// Notice that "virtual" is only needed in the declaration, not the definition. +void Dog::print() const +{ + std::cout << "Dog is " << name << " and weighs " << weight << "kg\n"; } -void Doggie::~doggieDestructor () { - delete[] name; - delete weight; +void Dog::~Dog() +{ + cout << "Goodbye " << name << "\n"; } -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; -} +int main() { + Dog myDog; // prints "A dog has been constructed" + myDog.setName("Barkley"); + myDog.setWeight(10); + myDog.printDog(); // prints "Dog is Barkley and weighs 10 kg" + return 0; +} // prints "Goodbye Barkley" +// Inheritance: -//C++ Class inheritance +// This class inherits everything public and protected from the Dog class +class OwnedDog : public Dog { -class German_Sheperd : public Doggie -{ - //This class now inherits everything public and protected from Doggie class + void setOwner(const std::string& dogsOwner) - //Good practice to put d_ in front of datatypes in classes - std::string d_type; + // Override the behavior of the print function for all OwnedDogs. See + // http://en.wikipedia.org/wiki/Polymorphism_(computer_science)#Subtyping + // for a more general introduction if you are unfamiliar with + // subtype polymorphism. + // The override keyword is optional but makes sure you are actually + // overriding the method in a base class. + void print() const override; - public: - void dogType() {d_type = "German Sheperd";} +private: + std::string owner; }; +// Meanwhile, in the corresponding .cpp file: - -/////////////////////////////////////// -// C++ Exception Handling -/////////////////////////////////////// - -try { - throw 12.25; // throws a double no handler declared -} catch (int errorNum) +void OwnedDog::setOwner(const std::string& dogsOwner) { - 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; + owner = dogsOwner; } +void OwnedDog::print() const +{ + Dog::print(); // Call the print function in the base Dog class + std::cout << "Dog is owned by " << owner << "\n"; + // Prints "Dog is <name> and weights <weight>" + // "Dog is owned by <owner>" +} -/////////////////////////////////////// -// C++ Operator Overloading -/////////////////////////////////////// +////////////////////////////////////////// +// Initialization and Operator Overloading +////////////////////////////////////////// -// In C++ you can overload operators such as +, -, new, etc. +// In C++ you can overload the behavior of operators such as +, -, *, /, etc. +// This is done by defining a function which is called +// whenever the operator is used. #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&); +class Point { +public: + // Member variables can be given default values in this manner. + double x = 0; + double y = 0; + + // Define a default constructor which does nothing + // but initialize the Point to the default value (0, 0) + Point() { }; + + // The following syntax is known as an initialization list + // and is the proper way to initialize class member values + Point (double a, double b) : + x(a), + y(b) + { /* Do nothing except initialize the values */ } + + // Overload the + operator. + Point operator+(const Point& rhs) const; + + // Overload the += operator + Point& operator+=(const Point& rhs); }; -Vector Vector::operator+ (const Vector& rhs) +Point Point::operator+(const Point& rhs) const { - Vector temp; - temp.x = x + rhs.x; - temp.y = y + rhs.y; - return temp; + // Create a new point that is the sum of this one and rhs. + return Point(x + rhs.x, y + rhs.y); } -Vector Vector::operator+= (const Vector& rhs) +Point& Point::operator+=(const Point& rhs) { x += rhs.x; y += rhs.y; @@ -331,20 +389,45 @@ Vector Vector::operator+= (const Vector& rhs) } 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) + Point up (0,1); + Point right (1,0); + // This calls the Point + operator + // Point up calls the + (function) with right as its paramater + Point result = up + right; + // Prints "Result is upright (1,1)" cout << "Result is upright (" << result.x << ',' << result.y << ")\n"; return 0; } +///////////////////// +// Exception Handling +///////////////////// + +// The standard library provides a few exception types +// (see http://en.cppreference.com/w/cpp/error/exception) +// but any type can be thrown an as exception +#include <exception> + +// All exceptions thrown inside the _try_ block can be caught by subsequent +// _catch_ handlers. +try { + // Do not allocate exceptions on the heap using _new_. + throw std::exception("A problem occurred"); +} +// Catch exceptions by const reference if they are objects +catch (const std::exception& ex) +{ + std::cout << ex.what(); +// Catches any exception not caught by previous _catch_ blocks +} catch (...) +{ + std::cout << "Unknown exception caught"; + throw; // Re-throws the exception +} ``` -Futher Reading +Futher Reading: -for more resources see: http://www.icce.rug.nl/documents/cplusplus/ +An up-to-date language reference can be found at +<http://cppreference.com/w/cpp> -for other reference material: http://www.cplusplus.com/doc/tutorial/ +Additional resources may be found at <http://cplusplus.com> |