C ++ Programming Languages

1. Sharif University of Technology C++ Programming Languages Lecturer: Omid Jafarinezhad Fall 2015 Lecture 3 Department of Computer Engineering

2. Outline • Differences between C and C++ • Extensions to C • Namespaces • String • IOStreams (input, output, file)

3. Differences between C and C++ • Strict type checking // Ok in C , Error in C ++ int main() { // Error : printf undeclared printf("Hello World\n"); } // Ok in C++ #include <stdio.h> int main() { printf("Hello World\n"); } int main() { // Error in C++: return-statement with no value, in function returning 'int' return; } // Ok in C++ int main() { }

4. Extensions to C • Function Overloading #include <stdio.h> voidshow(int val) { printf("Integer: %d\n", val); } voidshow(double val) { printf("Double: %lf\n", val); } voidshow(char const *val) { printf("String: %s\n", val); } int main() { show(12); show(3.1415); show("Hello World!\n"); }

5. Extensions to C • Function Overloading: • Do not use function overloading for functions doing conceptually different tasks. • C++ does not allow identically named functions to differ only in their return values.

6. Extensions to C • Default function arguments #include <stdio.h> int Sum(int a = 1, int b = 4) {return a + b;} int main() { printf("%d", Sum()); // arguments: 1 + 4 printf("%d”, Sum(20)); // arguments: 20 + 4 printf("%d", Sum(20, 5)); // arguments: 20 + 5 // Sum(,6); // Error }

7. Extensions to C • Default function arguments • Default arguments must be known at compile-time since at that moment arguments are supplied to functions. Therefore, the default arguments must be mentioned at the function's declaration, rather than at its implementation: // sample header file extern void two_ints(int a = 1, int b = 4); // code of function in, filename.ccp void two_ints(int a, int b) { ... }

8. Differences between C and C++ • NULL-pointers , 0-pointers and nullptr (C++ 11) #include <stdio.h> voidshow(int val) { printf("Integer: %d\n", val); } voidshow(double val) { printf("Double: %lf\n", val); } voidshow(char const *val) { printf("String: %s\n", val); } int main() { show(0); show(NULL); // show(0); show((char *)0); show(nullptr); // in C++ 11 }

9. Differences between C and C++ • The void parameter list #include <stdio.h> voidshow(); int main() { show(10); } voidshow(int val) { printf("Integer: %d\n", val); } C () C++ ()

10. Differences between C and C++ • The void parameter list #include <stdio.h> voidshow(void); int main() { show(10); // Error too many arguments to function } voidshow(int val) { printf("Integer: %d\n", val); } C () C++ ()

11. Differences between C and C++ • Defining local variables #include <stdio.h> int main() { for (int i = 0; i < 20; ++i) printf("%d\n", i); switch (int c = getchar()) { .... } if (int c = getchar()) …. }

12. Differences between C and C++ • typedef • The keyword typedef is still used in C++, but is not required anymore when defining union, struct or enum definitions. structSomeStruct { int a; double d; char string[80]; }; SomeStruct what; // in c : structSomeStruct what; what.d = 3.1415;

13. Extensions to C • Thescope resolution operator :: #include <stdio.h> int counter = 50; // global variable int main() { intcounter = 10; for (intcounter = 1; // this refers to the counter < 10; // local variable counter++) { printf("%d\n", ::counter // global variable / // divided by counter); // local variable } }

14. Extensions to C • cout, cin, and cerr • cout, analogous to stdout • cin, analogous to stdin • cerr, analogous to stderr

15. Extensions to C #include <iostream> using namespace std; int main() { int ival; char sval[30]; std::cout << "Enter a number:\n"; // <<, insertion operator cin >> ival; // >>, extraction operator cout << "And now a string:\n"; cin >> sval; cout << "The number is: " << ival << "\n" "And the string is: " << sval << '\n'; }

16. Extensions to C • Functions as part of a struct /* in C ++ */ struct Person { char name[80]; char address[80]; void print(); }; void Person::print() { cout << "Name:" << name << "\n" "Address: " << address << "\n"; } Person person; strcpy(person.name, "Karel"); person.print(); /* in C and C++*/ typedef struct { char name[80]; char address[80]; } PERSON; /* print information */ void print(PERSON const *p){…} /* etc.. */

17. Extensions to C • References • the reference operator & indicates that ref is not itself an int but a reference to one • synonyms for variables • A reference to a variable is like an alias // c++ int int_value; int &ref = int_value; ++int_value; ++ref; // c and c++ int int_value; int *ref = &int_value; ++int_value; ++(*ref);

18. Extensions to C • References // c++ void increase(int &valr) { valr += 5; } int main() { int x; increase(x); } // c and c++ void increase(int *valp) { *valp += 5; } int main() { int x; increase(&x); }

19. Extensions to C • References externint *ip; externint&ir; ip = 0; // reassigns ip, now a 0-pointer ir = 0; // ir unchanged, the int variable it refers to is now 0 int &q;// Error : declared as reference but not initialized

20. Extensions to C • References could result in extremely ugly code int &func() { static int value; return value; } int main() { func() = 20; func() += func(); }

21. Extensions to C • Rvalue References (C++11) • lvalue reference (typename &) • rvalue references (typename &&) int intVal() { return 5; } int &ir = intVal(); // fails: refers to a temporary int const &ic = intVal(); // OK: immutable temporary int *ip = &intVal(); // fails: no lvalue available

22. Extensions to C • Rvalue References (C++11) void receive(int &value) // note: lvalue reference { cout << "int value parameter\n"; } void receive(int &&value) // note: rvalue reference { cout << "int R-value parameter\n"; } int main() { receive(18); // int R-value parameter int value = 5; receive(value); // int value parameter receive(intVal()); // int R-value parameter }

23. Memory leak #include <stdlib.h> void function_which_allocates(void) { /* allocate an array of 45 floats */ float * a = malloc(sizeof(float) * 45); /* additional code making use of 'a' */ /* return to main, having forgotten to free the memory we malloc'd */ } int main(void) { function_which_allocates(); /* the pointer 'a' no longer exists, and therefore cannot be freed, but the memory is still allocated. a leak has occurred. */ }

24. Extensions to C • Memory leak struct Data { char *text; size_t size; void copy(Data const &other) { text = strdup(other.text); size = strlen(text); } }; Data dataFactory(char const *txt) { Data ret = {strdup(txt), strlen(txt)}; return ret; } int main() { Data d1 = {strdup("hello"), strlen("hello")}; Data d2; d2.copy(d1); Data d3; d3.copy(dataFactory("hello")); }

25. Extensions to C • Rvalue References (C++11) struct Data { // …. void copy(Data &&other) { text = other.text; other.text = 0; } }; Data dataFactory(char const *txt) { Data ret = {strdup(txt), strlen(txt)}; return ret; } int main() { Data d1 = {strdup("hello"), strlen("hello")}; Data d2; d2.copy(d1); Data d3; d3.copy(dataFactory("hello")); }

26. Extensions to C • Strongly typed enumerations (C++11) enum class SafeEnum { NOT_OK, // 0, by implication OK = 10, MAYBE_OK // 11, by implication }; enum class CharEnum: unsigned char { NOT_OK, OK }; // CharEnum::OK

27. Extensions to C • enumerations in c and c++ #include <iostream> using namespace std; enum Color {         RED, // 0         BLUE // 1 }; enum Fruit {         BANANA, // 0         APPLE // 1 }; int main() { Color a = RED; Fruit b = BANANA; // The compiler will compare a and b as integers if (a == b) // and find they are equal! cout << "a and b are equal" << endl; else         cout << "a and b are not equal" << endl; return 0; }

28. Extensions to C • Strongly typed enumerations (C++11) #include <iostream> using namespace std; enumclass Color {         RED, // 0         BLUE // 1 }; enum class Fruit {         BANANA, // 0         APPLE // 1 }; int main() { Color a = Color::RED; Fruit b = Fruit::BANANA; /* compile error here, as the compiler doesn't know how to compare different types Color and Fruit */ if (a == b) cout << "a and b are equal" << endl; else         cout << "a and b are not equal" << endl; return 0; }

29. Extensions to C • Type inference: auto and decltype(C++11) auto variable = 5; // int x = 4; auto d = 2.5; // d will be type double auto z = d; // z will be type double auto w = "hi"; // w will be type const char* decltype(5) x; // x will be type int because 5 is an int decltype(x) y = 6; // y will be type int because x is an int auto z = x; // z will type type int int multiply (int x, int y){…} auto multiply (int x, int y) -> int{…}

30. Extensions to C • function declaration using auto (C++11) #include <iostream> #include <string> // simple function with a default argument, returning nothing void f0(const std::string& arg = "world") { std::cout << "Hello, " << arg << '\n'; } // function returning a pointer to f0, (C++11 style) auto fp11() -> void(*)(const std::string&) { return f0; } // c and c++ (pre-C++11 style) // function returning a pointer to f0 void (*fp03())(const std::string&) { return f0; } int main() { f0(); fp11()("test"); fp03()("again"); } // output Hello, world Hello, test Hello, again

31. Extensions to C • Range-based for-loops (C++11) struct BigStruct { double array[100]; int last; }; BigStruct data[100]; // assume properly initialized elsewhere int countUsed() { int sum = 0; // const &: the elements aren't modified for(auto const &element: data) sum += element.last; return sum; } // assume int array[30] for (auto &element: array) statement

32. Extensions to C • binary constant • e.g. int i = 0b101; • data types • void, char, short, int, long, float and double • bool, wchar_t, long long and long double • char16_t and char32_t • size_t (typedef long unsigned int size_t)

33. Extensions to C • Bool bool bValue; // true (!=0) or false (0) bool bValue1 = true; // explicit assignment bool bValue2(false); // implicit assignment bool bValue1 = !true; // bValue1 will have the value false bool bValue2(!false); // bValue2 will have the value true bool bValue = true; // bool bValue = 30; cout << bValue << endl; // 1 cout << !bValue << std::endl; // 0 if (!bValue)     cout << "The if statement was true" << endl; else     cout << "The if statement was false" << endl;

34. Extensions to C • The static_cast conversion • static_cast<type>(expression); int x = 19; int y = 4; sqrt(x / y); sqrt(static_cast<double>(x) / y); • The dynamic_cast conversion • The const_cast conversion • The reinterpret_cast conversion

35. Namespaces • Defining namespaces // same as file3.ccp namespace CppNS { double cos(double argInDegrees) { ... } double sin(double argInDegrees) { ... } }

36. Namespaces • Referring to namespaces #include <file3> #include <iostream> #include <cmath> using namespace std; int main() { cout << "The cosine of 60 degrees is: " << CppNS::cos(60) << ::cos(60); // call the standard std::cos(60)function } // same as file3.ccp namespace CppNS { double cos(double argInDegrees) { … } double sin(double argInDegrees) { … } }

37. Namespaces • Referring to namespaces #include <file3> #include <iostream> #include <cmath> using namespace std; int main() { using CppNS::cos; /* ... */ cout << cos(60)// calls CppNS::cos() << ::cos(60); // call the standard std::cos(60)function } // same as file3.ccp namespace CppNS { double cos(double argInDegrees) { … } double sin(double argInDegrees) { … } }

38. Namespaces • The standard namespace • The std namespace is reserved by C++ • The standard defines many entities that are part of the runtime available software • e.g., cout, cin, cerr • the templates defined in the Standard Template Library • the Generic Algorithms

39. Namespaces • Nesting namespaces #include <file3> int main() { CppNS::value = 0; CppNS::Virtual::pointer = 0; } // same as file3.ccp namespace CppNS { int value; namespace Virtual { void *pointer; } } #include <file3> using namespace CppNS; int main() { value = 0; Virtual::pointer = 0; }

40. Namespaces • Nesting namespaces #include <file3> using namespace CppNS; using namespace Virtual; int main() { value = 0; pointer = 0; } // same as file3.ccp namespace CppNS { int value; namespace Virtual { void *pointer; } } #include <file3> using namespace CppNS ::Virtual; int main() { CppNS ::value = 0; pointer = 0; }

41. Namespaces • Namespace aliasing #include <file3> namespace CV = CppNS::Virtual; int main() { CV::pointer = 0; } // same as file3.ccp namespace CppNS { int value; namespace Virtual { void *pointer; } } #include <file3> namespace CV = CppNS::Virtual; using namespace CV; int main() { pointer = 0; }

42. Namespaces • Defining entities outside of their namespaces #include <file3> namespace CppNS { namespace Virtual { void *pointer; typedef int INT8[8]; INT8 *squares(); } } // out side the namespace such as in cpp file CppNS::Virtual::INT8 * CppNS ::Virtual::squares() { /* … */ } namespace CppNS { namespace Virtual { void *pointer; typedefint INT8[8]; INT8 *squares() { /* … */ } } }

43. String • std::string public class string { /* … */ string&string::operator= (const string& str); string& string::assign (const string& str); string& string::operator= (const char* str); string& string::assign (const char* str); string& string::operator= (char c); /* … */ } #include <iostream> #include <string> using namespace std; int main() { string sString; sString = string("One"); cout << sString << endl;  // One const string sTwo("Two"); sString.assign(sTwo); cout << sString << endl;  // Two sString = "Three";// Assign a C-style string cout << sString << endl;  // Three sString.assign("Four"); cout << sString << endl;  // Four sString = '5';// Assign a char cout << sString << endl;  // 5 string sOther; // Chain assignment sString = sOther = "Six"; cout << sString << " " << sOther << endl; // Six Six }

44. String • std::string assignment and swapping const string sSource("abcdefg"); string sDest; sDest.assign(sSource, 2, 4); cout << sDest << endl; // cdef sDest.assign("abcdefg", 4); cout << sDest << endl; // abcd sDest.assign(4, 'g'); cout << sDest << endl; // gggg string sStr1("red"); string sStr2("blue); cout << sStr1 << " " << sStr2 << endl; // red blue swap(sStr1, sStr2); cout << sStr1 << " " << sStr2 << endl; // blue red sStr1.swap(sStr2); cout << sStr1 << " " << sStr2 << endl; // red blue

45. String • std::string inserting #include <iostream> #include <string> using namespace std; int main() { string sString("aaaa"); cout << sString << endl; // aaaa sString.insert(2, string("bbbb")); cout << sString << endl; // aabbbbaa sString.insert(4, "cccc"); cout << sString << endl; // aabbccccbbaa const string sInsert("01234567"); // insert substring of sInsert from index [3,7) into sString at index 2 sString.insert(2, sInsert, 3, 4); // aa3456bbccccbbaa cout << sString << endl; }

46. String • std::string appending string sString("one"); sString += string(" two"); // sString += " two"; string sThree(" three"); sString.append(sThree); cout << sString << endl; // one two three string sString("one "); const string sTemp("twothreefour"); // append substring of sTemp starting at index 3 of length 5 sString.append(sTemp, 3, 5); cout << sString << endl; // one three

47. String • std::string Member functions • http://en.cppreference.com/w/cpp/string/basic_string access specified character with bounds checking clears the contents inserts characters removes characters compares two strings replaces specified portion of a string returns a substring copies characters find characters in the string find the last occurrence of a substring find first occurrence of characters find last occurrence of characters /* … */

48. String • std::string Member functions • http://en.cppreference.com/w/cpp/string/basic_string/at #include <stdexcept> #include <iostream> int main() { std::string s("message"); // for capacity s = "abc"; s.at(2) = 'x'; // ok std::cout << s << '\n'; std::cout << "string size = " << s.size() << '\n'; std::cout << "string capacity = " << s.capacity() << '\n'; try { // throw, even if capacity allowed to access element s.at(3) = 'x'; } catch (std::out_of_range& exc) { std::cout << exc.what() << '\n‘; } } abx string size = 3 string capacity = 7 basic_string::at

49. String • std::string Convert from strings • C++11 added several string conversion functions stoi Convert string to integer stol Convert string to long int stoul Convert string to unsigned integer stoll Convert string to long long stoull Convert string to unsigned long long stof Convert string to float stod Convert string to double stold Convert string to long double int stoi (const string& str, size_t* idx = 0, int base = 10); std::string str_bin = "-10010110001"; int i_bin = std::stoi (str_bin,nullptr,2); std::cout << str_bin << ": " << i_bin; // -10010110001: -1201

50. IOStreams • Input/output in C++ • istream class, extraction operator (>>) • ostream class, insertion operator (<<) #include <iostream> using namespace std; int main() { cout << "Enter your age: " << endl; // print text to the monitor int nAge; cin >> nAge; // get input from the user if (nAge <= 0) { // print an error message cerr << "Oops, you entered an invalid age!" << endl; return 1; } cout << "You entered " << nAge << " years old" << endl; return 0; }