summaryrefslogtreecommitdiffhomepage
path: root/c++.html.markdown
diff options
context:
space:
mode:
Diffstat (limited to 'c++.html.markdown')
-rw-r--r--c++.html.markdown145
1 files changed, 74 insertions, 71 deletions
diff --git a/c++.html.markdown b/c++.html.markdown
index dd4ba055..99e2feea 100644
--- a/c++.html.markdown
+++ b/c++.html.markdown
@@ -31,7 +31,7 @@ one of the most widely-used programming languages.
// Comparison to C
//////////////////
-// C++ is _almost_ a superset of C and shares its basic syntax for
+// C++ is almost a superset of C and shares its basic syntax for
// variable declarations, primitive types, and functions.
// Just like in C, your program's entry point is a function called
@@ -55,24 +55,26 @@ int main(int argc, char** argv)
// However, C++ varies in some of the following ways:
-// In C++, character literals are chars
-sizeof('c') == sizeof(char) == 1
+// In C++, character literals are chars, therefore the size is 1
+sizeof('c') == sizeof(char)
-// In C, character literals are ints
+// In C, character literals are ints, therefore the size is 4
sizeof('c') == sizeof(int)
// C++ has strict prototyping
void func(); // function which accepts no arguments
+void func(void); // same as earlier
// In C
-void func(); // function which may accept any number of arguments
+void func(); // function which may accept any number of arguments with unknown type
+void func(void); // function which accepts no arguments
// Use nullptr instead of NULL in C++
int* ip = nullptr;
-// C standard headers are available in C++.
-// C headers end in .h, while
+// Most C standard headers are available in C++.
+// C headers generally end with .h, while
// C++ headers are prefixed with "c" and have no ".h" suffix.
// The C++ standard version:
@@ -101,7 +103,7 @@ void print(char const* myString)
void print(int myInt)
{
- printf("My int is %d", myInt);
+ printf("My int is %d\n", myInt);
}
int main()
@@ -193,22 +195,24 @@ int main()
#include <iostream> // Include for I/O streams
-using namespace std; // Streams are in the std namespace (standard library)
-
int main()
{
int myInt;
// Prints to stdout (or terminal/screen)
- cout << "Enter your favorite number:\n";
+ // std::cout referring the access to the std namespace
+ std::cout << "Enter your favorite number:\n";
// Takes in input
- cin >> myInt;
+ std::cin >> myInt;
// cout can also be formatted
- cout << "Your favorite number is " << myInt << '\n';
+ std::cout << "Your favorite number is " << myInt << '\n';
// prints "Your favorite number is <myInt>"
- cerr << "Used for error messages";
+ std::cerr << "Used for error messages";
+
+ // flush string stream buffer with new line
+ std::cout << "I flushed it away" << std::endl;
}
//////////
@@ -218,22 +222,20 @@ int main()
// Strings in C++ are objects and have many member functions
#include <string>
-using namespace std; // Strings are also in the namespace std (standard library)
-
-string myString = "Hello";
-string myOtherString = " World";
+std::string myString = "Hello";
+std::string myOtherString = " World";
// + is used for concatenation.
-cout << myString + myOtherString; // "Hello World"
+std::cout << myString + myOtherString; // "Hello World"
-cout << myString + " You"; // "Hello You"
+std::cout << myString + " You"; // "Hello You"
// C++ string length can be found from either string::length() or string::size()
cout << myString.length() + myOtherString.size(); // Outputs 11 (= 5 + 6).
// C++ strings are mutable.
myString.append(" Dog");
-cout << myString; // "Hello Dog"
+std::cout << myString; // "Hello Dog"
// C++ can handle C-style strings with related functions using cstrings
#include <cstring>
@@ -254,35 +256,32 @@ cout << "Length = " << strlen(myOldString); // Length = 9
// No * is needed for dereferencing and
// & (address of) is not used for assignment.
-using namespace std;
+std::string foo = "I am foo";
+std::string bar = "I am bar";
-string foo = "I am foo";
-string bar = "I am bar";
-
-
-string& fooRef = foo; // This creates a reference to foo.
+std::string& fooRef = foo; // This creates a reference to foo.
fooRef += ". Hi!"; // Modifies foo through the reference
-cout << fooRef; // Prints "I am foo. Hi!"
+std::cout << fooRef; // Prints "I am foo. Hi!"
// Doesn't reassign "fooRef". This is the same as "foo = bar", and
// foo == "I am bar"
// after this line.
-cout << &fooRef << endl; //Prints the address of foo
+std::cout << &fooRef << '\n'; // Prints the address of foo
fooRef = bar;
-cout << &fooRef << endl; //Still prints the address of foo
-cout << fooRef; // Prints "I am bar"
+std::cout << &fooRef << '\n'; // Still prints the address of foo
+std::cout << fooRef << '\n'; // Prints "I am bar"
// The address of fooRef remains the same, i.e. it is still referring to foo.
-const string& barRef = bar; // Create a const reference to bar.
+const std::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.
// Sidetrack: Before we talk more about references, we must introduce a concept
// called a temporary object. Suppose we have the following code:
-string tempObjectFun() { ... }
-string retVal = tempObjectFun();
+std::string tempObjectFun() { ... }
+std::string retVal = tempObjectFun();
// What happens in the second line is actually:
// - a string object is returned from tempObjectFun
@@ -307,7 +306,7 @@ foo(bar(tempObjectFun()))
void constReferenceTempObjectFun() {
// constRef gets the temporary object, and it is valid until the end of this
// function.
- const string& constRef = tempObjectFun();
+ const std::string& constRef = tempObjectFun();
...
}
@@ -315,17 +314,17 @@ void constReferenceTempObjectFun() {
// objects. You cannot have a variable of its type, but it takes precedence in
// overload resolution:
-void someFun(string& s) { ... } // Regular reference
-void someFun(string&& s) { ... } // Reference to temporary object
+void someFun(std::string& s) { ... } // Regular reference
+void someFun(std::string&& s) { ... } // Reference to temporary object
-string foo;
+std::string foo;
someFun(foo); // Calls the version with regular reference
someFun(tempObjectFun()); // Calls the version with temporary reference
// For example, you will see these two versions of constructors for
// std::basic_string:
-basic_string(const basic_string& other);
-basic_string(basic_string&& other);
+std::basic_string(const basic_string& other);
+std::basic_string(basic_string&& other);
// Idea being if we are constructing a new string from a temporary object (which
// is going to be destroyed soon anyway), we can have a more efficient
@@ -586,7 +585,7 @@ int main () {
// Point up calls the + (function) with right as its parameter
Point result = up + right;
// Prints "Result is upright (1,1)"
- cout << "Result is upright (" << result.x << ',' << result.y << ")\n";
+ std::cout << "Result is upright (" << result.x << ',' << result.y << ")\n";
return 0;
}
@@ -654,7 +653,7 @@ barkThreeTimes(fluffy); // Prints "Fluffy barks" three times.
// Template parameters don't have to be classes:
template<int Y>
void printMessage() {
- cout << "Learn C++ in " << Y << " minutes!" << endl;
+ std::cout << "Learn C++ in " << Y << " minutes!\n";
}
// And you can explicitly specialize templates for more efficient code. Of
@@ -663,7 +662,7 @@ void printMessage() {
// even if you explicitly specified all parameters.
template<>
void printMessage<10>() {
- cout << "Learn C++ faster in only 10 minutes!" << endl;
+ std::cout << "Learn C++ faster in only 10 minutes!\n";
}
printMessage<20>(); // Prints "Learn C++ in 20 minutes!"
@@ -716,6 +715,9 @@ void doSomethingWithAFile(const char* filename)
// To begin with, assume nothing can fail.
FILE* fh = fopen(filename, "r"); // Open the file in read mode.
+ if (fh == NULL) {
+ // Handle possible error
+ }
doSomethingWithTheFile(fh);
doSomethingElseWithIt(fh);
@@ -855,9 +857,9 @@ delete ptr;
// Usage of "std::shared_ptr":
void foo()
{
-// It's no longer necessary to delete the Dog.
-std::shared_ptr<Dog> doggo(new Dog());
-doggo->bark();
+ // It's no longer necessary to delete the Dog.
+ std::shared_ptr<Dog> doggo(new Dog());
+ doggo->bark();
}
// Beware of possible circular references!!!
@@ -893,22 +895,23 @@ doggo_two = doggo_one; // p2 references p1
// Vector (Dynamic array)
// Allow us to Define the Array or list of objects at run time
#include <vector>
-string val;
-vector<string> my_vector; // initialize the vector
-cin >> val;
+std::string val;
+std::vector<string> my_vector; // initialize the vector
+std::cin >> val;
+
my_vector.push_back(val); // will push the value of 'val' into vector ("array") my_vector
my_vector.push_back(val); // will push the value into the vector again (now having two elements)
// To iterate through a vector we have 2 choices:
// Either classic looping (iterating through the vector from index 0 to its last index):
for (int i = 0; i < my_vector.size(); i++) {
- cout << my_vector[i] << endl; // for accessing a vector's element we can use the operator []
+ std::cout << my_vector[i] << '\n'; // for accessing a vector's element we can use the operator []
}
// or using an iterator:
vector<string>::iterator it; // initialize the iterator for vector
for (it = my_vector.begin(); it != my_vector.end(); ++it) {
- cout << *it << endl;
+ std::cout << *it << '\n';
}
// Set
@@ -917,7 +920,7 @@ for (it = my_vector.begin(); it != my_vector.end(); ++it) {
// without any other functions or code.
#include<set>
-set<int> ST; // Will initialize the set of int data type
+std::set<int> ST; // Will initialize the set of int data type
ST.insert(30); // Will insert the value 30 in set ST
ST.insert(10); // Will insert the value 10 in set ST
ST.insert(20); // Will insert the value 20 in set ST
@@ -929,9 +932,9 @@ ST.insert(30); // Will insert the value 30 in set ST
ST.erase(20); // Will erase element with value 20
// Set ST: 10 30
// To iterate through Set we use iterators
-set<int>::iterator it;
-for(it=ST.begin();it!=ST.end();it++) {
- cout << *it << endl;
+std::set<int>::iterator it;
+for(it = ST.begin(); it != ST.end(); it++) {
+ std::cout << *it << '\n';
}
// Output:
// 10
@@ -939,7 +942,7 @@ for(it=ST.begin();it!=ST.end();it++) {
// To clear the complete container we use Container_name.clear()
ST.clear();
-cout << ST.size(); // will print the size of set ST
+std::cout << ST.size(); // will print the size of set ST
// Output: 0
// NOTE: for duplicate elements we can use multiset
@@ -951,7 +954,7 @@ cout << ST.size(); // will print the size of set ST
// and a mapped value, following a specific order.
#include<map>
-map<char, int> mymap; // Will initialize the map with key as char and value as int
+std::map<char, int> mymap; // Will initialize the map with key as char and value as int
mymap.insert(pair<char,int>('A',1));
// Will insert value 1 for key A
@@ -959,16 +962,16 @@ mymap.insert(pair<char,int>('Z',26));
// Will insert value 26 for key Z
// To iterate
-map<char,int>::iterator it;
+std::map<char,int>::iterator it;
for (it=mymap.begin(); it!=mymap.end(); ++it)
- std::cout << it->first << "->" << it->second << std::endl;
+ std::cout << it->first << "->" << it->second << '\n';
// Output:
// A->1
// Z->26
// To find the value corresponding to a key
it = mymap.find('Z');
-cout << it->second;
+std::cout << it->second;
// Output: 26
@@ -1006,7 +1009,7 @@ fooMap.find(Foo(1)); //true
// For example, consider sorting a vector of pairs using the second
// value of the pair
-vector<pair<int, int> > tester;
+std::vector<pair<int, int> > tester;
tester.push_back(make_pair(3, 6));
tester.push_back(make_pair(1, 9));
tester.push_back(make_pair(5, 0));
@@ -1014,7 +1017,7 @@ tester.push_back(make_pair(5, 0));
// Pass a lambda expression as third argument to the sort function
// sort is from the <algorithm> header
-sort(tester.begin(), tester.end(), [](const pair<int, int>& lhs, const pair<int, int>& rhs) {
+std::sort(tester.begin(), tester.end(), [](const pair<int, int>& lhs, const pair<int, int>& rhs) {
return lhs.second < rhs.second;
});
@@ -1028,7 +1031,7 @@ sort(tester.begin(), tester.end(), [](const pair<int, int>& lhs, const pair<int,
// 4. same as 3, but by value [=]
// Example:
-vector<int> dog_ids;
+std::vector<int> dog_ids;
// number_of_dogs = 3;
for(int i = 0; i < 3; i++) {
dog_ids.push_back(i);
@@ -1133,33 +1136,33 @@ const int maxL = 15;
auto second = make_tuple(maxN, maxL);
// Printing elements of 'first' tuple
-cout << get<0>(first) << " " << get<1>(first) << '\n'; //prints : 10 A
+std::cout << get<0>(first) << " " << get<1>(first) << '\n'; //prints : 10 A
// Printing elements of 'second' tuple
-cout << get<0>(second) << " " << get<1>(second) << '\n'; // prints: 1000000000 15
+std::cout << get<0>(second) << " " << get<1>(second) << '\n'; // prints: 1000000000 15
// Unpacking tuple into variables
int first_int;
char first_char;
tie(first_int, first_char) = first;
-cout << first_int << " " << first_char << '\n'; // prints : 10 A
+std::cout << first_int << " " << first_char << '\n'; // prints : 10 A
// We can also create tuple like this.
tuple<int, char, double> third(11, 'A', 3.14141);
// tuple_size returns number of elements in a tuple (as a constexpr)
-cout << tuple_size<decltype(third)>::value << '\n'; // prints: 3
+std::cout << tuple_size<decltype(third)>::value << '\n'; // prints: 3
// tuple_cat concatenates the elements of all the tuples in the same order.
auto concatenated_tuple = tuple_cat(first, second, third);
// concatenated_tuple becomes = (10, 'A', 1e9, 15, 11, 'A', 3.14141)
-cout << get<0>(concatenated_tuple) << '\n'; // prints: 10
-cout << get<3>(concatenated_tuple) << '\n'; // prints: 15
-cout << get<5>(concatenated_tuple) << '\n'; // prints: 'A'
+std::cout << get<0>(concatenated_tuple) << '\n'; // prints: 10
+std::cout << get<3>(concatenated_tuple) << '\n'; // prints: 15
+std::cout << get<5>(concatenated_tuple) << '\n'; // prints: 'A'
///////////////////////////////////
@@ -1207,7 +1210,7 @@ compl 4 // Performs a bitwise not
4 xor 3 // Performs bitwise xor
```
-Further Reading:
+## Further Reading:
* An up-to-date language reference can be found at [CPP Reference](http://cppreference.com/w/cpp).
* A tutorial for beginners or experts, covering many modern features and good practices: [LearnCpp.com](https://www.learncpp.com/)