{"id":12086,"date":"2017-11-27T16:28:27","date_gmt":"2017-11-27T21:28:27","guid":{"rendered":"http:\/\/jianmingli.com\/wp\/?p=12086"},"modified":"2018-04-13T09:58:54","modified_gmt":"2018-04-13T14:58:54","slug":"book-note-beginning-c","status":"publish","type":"post","link":"https:\/\/jianmingli.com\/wp\/?p=12086","title":{"rendered":"Book Note: Beginning C++"},"content":{"rendered":"
\n

Contents<\/h2>\n
    \n\t
  1. \n\t\tOverview<\/a>\n\t\t
      \n\t\t\t
    1. \n\t\t\t\tNamespaces<\/a>\n\t\t\t<\/li>\n\t\t<\/ol>\n\t
    2. \n\t\tData Types<\/a>\n\t\t
        \n\t\t\t
      1. \n\t\t\t\tInteger<\/a>\n\t\t\t<\/li>\n\t\t\t
      2. \n\t\t\t\tConstants<\/a>\n\t\t\t<\/li>\n\t\t\t
      3. \n\t\t\t\tInteger Operators<\/a>\n\t\t\t<\/li>\n\t\t\t
      4. \n\t\t\t\tExplicit Type Casting<\/a>\n\t\t\t<\/li>\n\t\t\t
      5. \n\t\t\t\tFloating-Point<\/a>\n\t\t\t<\/li>\n\t\t\t
      6. \n\t\t\t\tlvalue and rvalue<\/a>\n\t\t\t<\/li>\n\t\t\t
      7. \n\t\t\t\tBitwise operators<\/a>\n\t\t\t<\/li>\n\t\t\t
      8. \n\t\t\t\tEnumerated Data Types<\/a>\n\t\t\t<\/li>\n\t\t\t
      9. \n\t\t\t\tSynonyms for data types: typedef<\/a>\n\t\t\t<\/li>\n\t\t\t
      10. \n\t\t\t\tVariable Scopes<\/a>\n\t\t\t<\/li>\n\t\t\t
      11. \n\t\t\t\tComparisons<\/a>\n\t\t\t<\/li>\n\t\t\t
      12. \n\t\t\t\tConditions<\/a>\n\t\t\t<\/li>\n\t\t\t
      13. \n\t\t\t\tArrays<\/a>\n\t\t\t<\/li>\n\t\t<\/ol>\n\t
      14. \n\t\tLoops<\/a>\n\t<\/li>\n\t
      15. \n\t\tPointers and References<\/a>\n\t\t
          \n\t\t\t
        1. \n\t\t\t\tPointer<\/a>\n\t\t\t<\/li>\n\t\t\t
        2. \n\t\t\t\tAddress-Of Operator: &<\/a>\n\t\t\t<\/li>\n\t\t\t
        3. \n\t\t\t\tIndirection Operator: *<\/a>\n\t\t\t<\/li>\n\t\t\t
        4. \n\t\t\t\tDynamic Memory Allocation<\/a>\n\t\t\t<\/li>\n\t\t\t
        5. \n\t\t\t\tSmart Pointers<\/a>\n\t\t\t<\/li>\n\t\t\t
        6. \n\t\t\t\tReferences<\/a>\n\t\t\t<\/li>\n\t\t<\/ol>\n\t
        7. \n\t\tFunctions<\/a>\n\t<\/li>\n\t
        8. \n\t\tLamda Expressions<\/a>\n\t<\/li>\n\t
        9. \n\t\tPreprocessing Directives<\/a>\n\t\t
            \n\t\t\t
          1. \n\t\t\t\tLinkage for a Name<\/a>\n\t\t\t<\/li>\n\t\t\t
          2. \n\t\t\t\tPreprocessing Source Code<\/a>\n\t\t\t<\/li>\n\t\t\t
          3. \n\t\t\t\tUsing Header Files<\/a>\n\t\t\t<\/li>\n\t\t<\/ol>\n\t
          4. \n\t\tClasses<\/a>\n\t<\/li>\n\t
          5. \n\t\tOperator Overloading<\/a>\n\t<\/li>\n\t
          6. \n\t\tInheritance<\/a>\n\t<\/li>\n\t
          7. \n\t\tPolymorphism<\/a>\n\t<\/li>\n\t
          8. \n\t\tRuntime Errors and Exception<\/a>\n\t<\/li>\n\t
          9. \n\t\tClass Templates<\/a>\n\t<\/li>\n\t
          10. \n\t\tFile IO<\/a>\n\t<\/li>\n\t
          11. \n\t\tReferences<\/a>\n\t<\/li>\n<\/ol>\n<\/ol>\n<\/div>\n
             <\/div>\n

            Overview<\/h2><\/span>\n

            * Latest standard: C++14
            \n* Compile command with Visual Studion command line<\/p>\n

            \r\ncl \/EHsc test.cpp\r\n<\/pre>\n
            * Comments (same as Java and C#):<\/p>\n
            \r\n\/\/ this is a comment\r\n\/* this is another\r\n   comment\r\n*\/\r\n<\/pre>\n
            * Preprocessing directives and header files
            \n– Header files: contains definitions such as variable and function definitions
            \n– May not contain implementations,
            \n– So that source files can be compiled without implementation<\/p>\n
            \r\n#include \r\n<\/pre>\n
            * Functions<\/p>\n
            \r\nint main()\r\n{\r\n  int answer {42};\r\n  std::cout << \"Hello world! The answer is \"\r\n    << answer\r\n\t<< std::endl;\r\n  return 0;\r\n}\r\n<\/pre>\n
            * Templates
            \n- Class templates: used by compiler to generate classes
            \n- Function templates: used by compiler to generate functions<\/p>\n
            * Program files
            \n- Source files: .cpp
            \n- Header files: .h or .hpp
            \n- Other files, e.g. resource files<\/p>\n
            * Standard Library
            \n* Standard template library (STL): is a subset of standard library<\/p>\n
            * How an executable file is created:
            \n- source fiels > compile into > object files > linked into > executable file<\/p>\n
            Namespaces<\/h3><\/span>\n
            * Only function prototype are required to be in a namespace<\/p>\n
            \r\n\/\/ Define namespace\r\nnamespace my_ns {\r\n\t\/\/ function prototypes\r\n}\r\n\r\n\/\/ import namespace\r\nusing namespace my_ns;\r\nusing namespace std;\r\nusing std::cout;\r\n<\/pre>\n
            * Unnamed namespace:
            \n- everything that's defined can NOT be accessed outside the unnamed namespace<\/p>\n
            \r\nnamespace {\r\n\t\/\/ function prototypes\r\n}\r\n\r\n* Nested namespaces\r\n
            \r\nouter::inner::normalize(data);\r\n<\/pre>\n
            * Namespace alias<\/p>\n
            \r\nnamespace alias_name = original_namespace_name;\r\n\r\n\/\/ for example:\r\nnamespace ublas = boost::numeric::ublas;\r\nublas::vector v;\r\n<\/pre>\n
            Data Types<\/h2><\/span>\n
            Integer<\/h3><\/span>\n
            * int<\/p>\n
            \r\nint apple_count;\r\nint apple_count {15};\r\nint foot_count {2}, toe_count {10}, head_count {1};\r\n<\/pre>\n
            * Signed Integer Types
            \nsigned char: 1 byte
            \nshort
            \nshort int: 2 bytes
            \nint: 4 bytes
            \nlong
            \nlong int: 4 bytes
            \nlong long
            \nlong long int: 8 bytes<\/p>\n
            \r\nsigned char ch {20};\r\nlong temperature {-50L};\r\nlong width {500L};\r\nlong long height {250LL};\r\nunsigned int toe_count {10U};\r\nunsigned long angel_count {1000000UL};\r\n<\/pre>\n
            Constants<\/h3><\/span>\n
            \r\nconst unsigned int toe_count {2U};\r\n<\/pre>\n
            Integer Operators<\/h3><\/span>\n
            + - * \/ %
            \nop=, e.g. += -= *= \/=
            \n++var var++ --var var--
            \nsizeof: bytes occupied by a type<\/p>\n
            Explicit Type Casting<\/h3><\/span>\n
            static_cast(expression)<\/p>\n
            \r\ndouble value1 {10.5};\r\ndouble value2 {15.5};\r\nint whole_number {static_cast(value1) + static_cast(value2)};\r\n<\/pre>\n
            Floating-Point<\/h3><\/span>\n
            float: pricision 7
            \ndouble: pricision 15
            \nlong double: : pricision 19<\/p>\n
            lvalue and rvalue<\/h3><\/span>\n
            Bitwise operators<\/h3><\/span>\n
            \r\n~ & ^ |\r\n<\/pre>\n
            Enumerated Data Types<\/h3><\/span>\n
            \r\n#include \r\n#include \r\nusing std::setw;\r\n\r\nint main()\r\n{\r\n  enum class Day { Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday }\r\n                                    yesterday{ Day::Monday }, today{ Day::Tuesday },                                     tomorrow{ Day::Wednesday };\r\n  Day poets_day{ Day::Friday };\r\n\r\n  enum class Punctuation : char { Comma = ',', Exclamation = '!', Question = '?' };\r\n  Punctuation ch{ Punctuation::Comma };\r\n\r\n  std::cout << \"yesterday's value is \" << static_cast(yesterday)\r\n    << static_cast(ch) << \" but poets_day's is \" << static_cast(poets_day)\r\n    << static_cast(Punctuation::Exclamation) << std::endl;\r\n\r\n  today = Day::Thursday;                    \/\/ Assign a new ...\r\n  ch = Punctuation::Question;               \/\/ ... enumerator values\r\n  tomorrow = poets_day;                     \/\/ Copy enumerator value\r\n\r\n  std::cout << \"Is today's value(\" << static_cast(today)\r\n   << \") the same as poets_day(\" << static_cast(poets_day)\r\n   << \")\" << static_cast(ch) << std::endl;\r\n\r\n\/\/   ch = tomorrow;                         \/\/ Uncomment ...\r\n\/\/   tomorrow = Friday;                     \/\/ ... any of these ...\r\n\/\/   today = 6;                             \/\/ ... for an error.\r\n}\r\n<\/pre>\n
            Synonyms for data types: typedef<\/h3><\/span>\n
            \r\ntypedef long BigOnes;                  \/\/ Defines BigOnes as a type alias\r\nBigOnes mynum {};                      \/\/ Define & initialize as type long\r\n\r\nusing BigOnes = long;                  \/\/ Defines BigOnes as a type alias\r\nusing PhoneBook = std::map, std::string>;\r\n<\/pre>\n
            Variable Scopes<\/h3><\/span>\n
            * Global variables
            \n* Static variables: defined within a block but continue to exist during program lifetime<\/p>\n
            \r\nint& f() {\r\n    static int x = 0;\r\n    return x;\r\n} \r\n<\/pre>\n
            * External variables: variable defined in another source file<\/p>\n
            \r\n\/\/ File1.cpp\r\nint shared_value {100};           \/\/ Global variable\r\n\r\n\/\/ Other program code ...\r\n\r\n\/\/ File2.cpp\r\nextern int shared_value;         \/\/ Declare variable to be external\r\n\r\nint main()\r\n{\r\n  int local_value {shared_value + 10};\r\n  \/\/ Plus other code...\r\n}\r\n<\/pre>\n
            Comparisons<\/h3><\/span>\n
            * Comparison operators:<\/p>\n
            \r\n< <= > >= == !=\r\n<\/pre>\n
            * Logical operators:<\/p>\n
            \r\n&& || !\r\n<\/pre>\n
            Conditions<\/h3><\/span>\n
            * if\/else if\/else
            \n* switch<\/p>\n
            Arrays<\/h3><\/span>\n
            \r\ndouble temperatures[366];\r\ntemperatures[3] = 70.0;\r\n\r\nunsigned int height[6] {};\r\nunsigned int height[6] {26, 37, 47, 55, 62, 75};\r\n\r\n\/\/ std::array\r\nstd::array values;\r\nvalues.fill(3.1415926);\r\ndouble total {};\r\nfor(size_t i {} ; i < values.size() ; ++i)\r\n{\r\n  total += values[i];\r\n  \/\/total += values.at(i);\r\n  \r\n}\r\nfor(auto value : values)\r\n{\r\n  total += value;\r\n}\r\n\r\n<\/pre>\n
            Loops<\/h2><\/span>\n
            * for loop<\/p>\n
            \r\nint sum {};\r\nfor(size_t i {} ; i < sizeof (values)\/sizeof (values[0]) ; ++i)\r\n{\r\n\tsum += values[i];\r\n}\r\n  \r\nint values [] {2, 3, 5, 7, 11, 13, 17, 19, 23, 29};\r\nint total {};\r\nfor(int x : values)\r\n\ttotal += x;  \r\n<\/pre>\n
            * while loop<\/p>\n
            \r\nwhile(){\r\n\t\/\/continue;\r\n\t\/\/break;\r\n}\r\n\r\ndo{\r\n}while()\r\n<\/pre>\n
            Pointers and References<\/h2><\/span>\n
            Pointer<\/h3><\/span>\n
            * A pointer is a variable that can be used to store an address<\/p>\n
            \r\n\/\/ Define a pointer\r\nlong* pnumber{nullptr};\r\n<\/pre>\n
            Address-Of Operator: &<\/h3><\/span>\n
            * Obtains the address of a variable<\/p>\n
            \r\n\/\/ Define a number\r\nlong number {12345L};\r\n\/\/ Assign address of number variable to pnumber pointer\r\nlong* pnumber {&number};\r\n<\/pre>\n
            Indirection Operator: *<\/h3><\/span>\n
            * aka dereference operator
            \n* Applying * to a ponter accesses the contents of the memory location to which it points<\/p>\n
            \r\n\tlong number {12345L};\r\n\tlong* pnumber {nullptr};\r\n\tpnumber = &number;\r\n\t\r\n\tstd::cout << \"Dereferencing, *pnumber = \" << *pnumber << std::endl;\r\n<\/pre>\n
            * Constant pointer pointing to constant array:
            \n- Array elements cannot be modified<\/p>\n
            \r\nconst char* const pstars[] {\r\n\t \"Fatty Arbuckle\", \"Clara Bow\",\r\n\t \"Lassie\", \"Slim Pickens\",\r\n\t \"Boris Karloff\", \"Mae West\",\r\n\t \"Oliver Hardy\", \"Greta Garbo\"\r\n   };\r\n<\/pre>\n
            Dynamic Memory Allocation<\/h3><\/span>\n
            \r\n\/\/ declare a pointer of double type\r\ndouble* pvalue{nullptr};\r\n\/\/ reserver memory for pvalue\r\npvalue = new double;\r\n\/\/ assign value to pointer\r\n*pvalue = 3.14;\r\n\/\/ release memory reserved by pointer\r\ndelete pvalue;\r\npvalue = nullptr;\r\n\r\n\/\/ another way\r\ndouble* pval2 {nullptr};\r\npval2 = new double{3.14};\r\n\/\/ release memory reserved by pointer\r\ndelete pval2;\r\npval2 = nullptr;\r\n\r\n\/\/ third way\r\ndoulbe* pval3 {new double{3.14});\r\n\/\/ release memory reserved by pointer\r\ndelete pval3;\r\npval3 = nullptr;\r\n<\/pre>\n
            Smart Pointers<\/h3><\/span>\n
            * A unique_ptr object behaves as a pointer to type T and is unique,
            \n- which means there cannot be more than one unique_ptr object containing the same address<\/p>\n
            \r\nstd::unique_ptr pdata {new double{999.0}};\r\n\/\/ reset to nullptr\r\npdata.reset(); \r\n<\/pre>\n
            * A shared_ptr object behaves as a pointer to type T,
            \n- in contrast with unique_ptr, there can be any number of shared_ptr objects containing the same address. <\/p>\n
            \r\nstd::shared_ptr pdata {new double{999.0}};\r\n\/\/ or better\r\nauto pdata = std::make_shared(999.0); \r\n<\/pre>\n
            * A weak_ptr is linked to a shared_ptr and contains the same address.
            \n- Its memory will be released when the last shared_ptr referencing it is destroyed or reassigned to point to a different address, even though associated weak_ptr objects may still exist.<\/p>\n
            \r\nauto pData = std::make_shared();     \/\/ Create a pointer to an object of type X\r\nstd::weak_ptr pwData {pData};        \/\/ Create a weak pointer from shared pointer\r\nstd::weak_ptr pwData2 {pwData};      \/\/ Create a weak pointer from another\r\n<\/pre>\n
            References<\/h3><\/span>\n
            * lvalue reference<\/p>\n
            \r\ndouble data {3.5};\r\n\/\/ define lvlaue reference for data variable\r\ndouble& rdata {data};\r\n\/\/ use exactly like data varilable (no need to dereference like using pointer)\r\nrdata += 2.5;\r\n\r\n\/\/ use reference to modify an array\r\ndouble temperatures[] {45.5, 50.0. 48.2. 57.0. 63.8};\r\nconst double F_to_C {5.0\/9.0};         \/\/ Convert Fahrenheit to Centigrade\r\nfor(auto& t : temperatures)            \/\/ lvalue reference loop variable\r\n  t = (t - 32.0)*FtoC;\r\n<\/pre>\n
            Functions<\/h2><\/span>\n
            * Syntax<\/p>\n
            \r\nreturn_type function_name (parameter_list)\r\n{\r\n  \/\/ Code for the function...\r\n}\r\n<\/pre>\n
            * Funciton prototypes
            \n- Function prototypes are declared either in the beginning of source file or in header files
            \n- Actual implementation can appear later in the source file
            \n- So that they can be used in main()<\/p>\n
            \r\n\/\/ function prototype so that you can use this funciton in main()\r\ndouble power(double x, int n);\r\n\r\nint main(){\r\n\t\/\/ use function\r\n}\r\n\r\n\/\/ Actual function implementaiton\r\ndouble power(double x, int n){\r\n\t\/\/ implementation\r\n}\r\n<\/pre>\n
            * Pass by pointer <\/p>\n
            \r\n#include \r\n\r\ndouble change_it(double* pointer_to_it);\r\n\r\nint main(){\r\n\tdouble it{5.0};\r\n\tdouble result {change_it(&it)};\r\n\tstd::cout << \"Outside function, result = \" << result << std::endl;\r\n}\r\n\r\ndouble change_it(double* pit){\r\n\t*pit += 10.0;\r\n\tstd::cout << \"Within function, *pit = \" << *pit << std::endl;\r\n\treturn *pit;\r\n}\r\n<\/pre>\n
            * Pass by reference<\/p>\n
            \r\n<\/pre>\n
            * Arguments to main()<\/p>\n
            \r\n#include \r\n\r\nint main(int argc, char* argv[])\r\n{\r\n  for (int i {} ; i < argc ; ++i)\r\n    std::cout << i << \": \" << argv[i] << std::endl;\r\n}\r\n<\/pre>\n
            * Default arguments<\/p>\n
            \r\n\/\/ Define default argument value in function prototype\r\nvoid show_error(const string& message =\u00a0\"Program Error\");\r\n\r\nvoid show_error(const string& message)\r\n{\u00a0\u00a0\r\n\tstd::cout << message << std::endl;\r\n}\r\n\r\nshow_error(); \/\/ outputs \"Program Error\"\r\n<\/pre>\n
            * Return values from a function
            \n- never return address of a local variable from a function
            \n- never return a reference to a local variable from a function<\/p>\n
            \r\nstring& larger(string& s1, string& s2)\r\n{\r\n  return s1 > s2 ? s1 : s2;             \/\/ Return a reference to the larger string\r\n}\r\n<\/pre>\n
            * Inline functions
            \n- place them in header files
            \n- it signals that compiler can rewrite the function for performance gains<\/p>\n
            \r\ninline int larger(int m, int n)\r\n{\r\n  return m  > n ? m  : n;\r\n}\r\n<\/pre>\n
            * static variables inside a function
            \n- so that variable values can be retains throughout runtime<\/p>\n
            void nextInteger()\r\n{\r\n  static int count {1}; \/\/ retains thru entire runtime\r\n  std::cout << count++ << std::endl;\r\n}\r\n<\/pre>\n
            * Function overloading<\/p>\n
            * Function template<\/p>\n
            \r\ntemplate  T larger(T a, T b);    \/\/ Function template prototype\r\n\r\nint main(){\r\n\tstd::cout << \"Larger of 1.5 and 2.5 is \" << larger(1.5, 2.5) << std::endl;\r\n\tstd::cout << \"Larger of 3.5 and 4.5 is \" << larger(3.5, 4.5) << std::endl;\r\n\r\n\t\/\/ explict template argument\r\n\tstd::cout << \"Larger of \" << a_long << \" and 9.5 is \"\r\n          << larger(a_long, 9.5) << std::endl;   \/\/ Outputs 9.5\r\n  \r\n}\r\n\r\n\/\/ Template for functions to return the larger of two values\r\ntemplate  T larger(T a, T b)\r\n{\r\n    return a > b ? a : b;\r\n}\r\n\r\n\/\/ Specialization of the template\r\ntemplate <> long* larger(long* a, long* b)\r\n{\r\n  return *a > *b ? a : b;\r\n}\r\n<\/pre>\n
            Lamda Expressions<\/h2><\/span>\n
            * A lamda expression is an anonymouse function
            \n* Mainly used to pass a function as argument to another function
            \n- it can access variables that exist in the enclosing scope where it is defined so an alternative to function pointer
            \n* [], called lamda introducer, signifies a lamda expression<\/p>\n
            \r\n\/\/ define a lamda expression\r\n[] (double value) { return value*value*value; }\r\n\r\n\/\/ specify return type\r\n[] (double value) -> double { return value*value*value; }\r\n\r\n\/\/ execute lamda expression and assign result to a variable\r\ndouble cube {};\r\ncube = [] (double value) -> double { return value*value*value; }(3.5);   \/\/ 42.875\r\n\r\n\/\/ Use lamda expression to initialize a variable\r\ncube {[] (double value) -> double { return value*value*value; }(3.5)};   \/\/ 42.875\r\n\r\n\/\/ Assign lamda expression to a variable\r\nauto cube = [] (double value) -> double { return value*value*value; };\r\n\r\n<\/pre>\n
            * Passing a lamda expression to a function<\/p>\n
            \r\n#include \r\n#include \r\n#include \r\n\r\n\/\/ Define a function template that accept a function as argument\r\n\/\/ F type matches any function that accepts double as argument and returns double\r\ntemplate \r\nstd::vector& change(std::vector& vec, F func){\r\n\tfor (auto& x : vec){\r\n\t\tx = func(x);\r\n\t}\r\n\treturn vec;\r\n}\r\n\r\n\/\/ Same as using function pointer\r\nstd::vector& change2(std::vector& vec, double(*func)(double)){\r\n\tfor (auto& x : vec){\r\n\t\tx = func(x);\r\n\t}\r\n\treturn vec;\r\n}\r\n\r\n\/\/ Same but using std::function template type\r\nstd::vector& change3(std::vector& vec, std::function fun)\r\n{\r\n  for (auto& x : vec)\r\n    x = fun(x);\r\n\r\n  return vec;\r\n}\r\n\r\nint main(){\r\n\t\/\/ Define cube lamda expression\r\n\tauto cube = [](double value) -> double {return value*value*value;};\r\n\t\r\n\t\/\/ Define average lamda expression\r\n\tauto average = [](const std::vector& v) -> double{\r\n\t\tdouble sum{};\r\n\t\tfor (auto x : v){\r\n\t\t\tsum += x;\r\n\t\t}\r\n\t\treturn sum \/ v.size();\r\n\t};\r\n\t\r\n\tstd::vector data {1.5, 2.5, 3.5, 4.5, 5.5};\r\n\tstd::cout << \"Average of values in data is \" << average(data) << std::endl;\r\n\r\n\t\/\/ Using function template and passing in lamda expression as function argument\r\n\tchange(data, [] (double x){return (x + 1.0)*(x + 2.0);});\r\n\tstd::cout << \"Average of changed values in data is \" << average(data) << std::endl;\r\n\t\r\n\t\/\/ Using function template and passing in cube lamda expression as function argument\r\n\tstd::cout << \"Average of cubes of values in data is \" << average(change3(data, cube)) << std::endl;\r\n}\r\n<\/pre>\n
            * Lamda function capture clause<\/p>\n
            \r\n\/\/ []: stateless lambda expression\r\n\/\/ lambda exp body cannot access any variables in its enclosing scope\r\n[] (double value) { return value*value*value; }\r\n\r\n\/\/ [=]: lambda exp body can access all variable values in its enclosing scope\r\n\/\/ cannot change variable values though\r\nstd::vector data {1.5, 2.5, 3.5, 4.5, 5.5};\r\ndouble factor {10.0};\r\nchange(data, [=](double x){ return factor*x; }); \/\/ can access factor by value; cannot change factor's value\r\nstd::cout << \"The values in data are now:\\n\"\r\nfor(const auto& x : data)\r\n  std::cout << \" \" << x;\r\nstd::cout << std::endl;\r\n\r\n\/\/[&]: same as [=] but can change variable values\r\nchange(data, [&](double x) { \r\n\tfactor += 2.0; \/\/ factor value can be changed here\r\n    return factor*x; }\r\n);\r\n\r\n\/\/[&var]: same as [&] but only var value can be changed\r\nchange(data, [&factor](double x) { \r\n\tfactor += 2.0; \/\/ factor value can be changed here, all other variables cannot be chagned\r\n    return factor*x; }\r\n);\r\n\r\n\/\/[=, &var]: only var value can be changed, all other variables can be accessed by values\r\nchange(data, [=, &factor](double x) { \r\n\tfactor += 2.0; \/\/ factor value can be changed here, all other variables cannot be chagned\r\n    return factor*x; }\r\n);\r\n\r\n\/\/[&, var]: all variables can be changed, var can only be accessed by value\r\nchange(data, [&, factor](double x) { \r\n\tfactor += 2.0; \/\/ factor value can be changed here, all other variables cannot be chagned\r\n    return factor*x; }\r\n);\r\n<\/pre>\n
            Preprocessing Directives<\/h2><\/span>\n
            * Translation unit: each source file + included header files
            \n* Translation unit -compiler-> object file -linker-> executable file
            \n* One definition rule: each variable, function, class type, enumeration type, or template in a translation unit must only be defined once.<\/p>\n
            Linkage for a Name<\/h3><\/span>\n
            * Internal linkage: can be accessed from anywhere within the same translation unit but NOT outside, e.g. global scope const var<\/p>\n
            \r\nconst double pi {3.14159265};\r\n<\/pre>\n
            * External linkage: can be accessed from another translation unit in addition to the one in which it is defined
            \n* No linkage: can be accessed from within the scope that applies to the name, e.g. names defined within a block.<\/p>\n
            \r\nextern const double pi {3.14159265};\r\n<\/pre>\n
            * Access variable name defined outside current translation unit:<\/p>\n
            \r\nextern double pi; \/\/ pi has been declared outside current translation unit already but we want to use it here\r\n<\/pre>\n
            Preprocessing Source Code<\/h3><\/span>\n
            \r\n#include\r\n\t#include  \/\/ iostream header contents are included\r\n\t#include \"myheader.h\" \/\/ include myheader.h file in the current directory\r\n\t\r\n#define\r\n\t#define BLACK WHITE \/\/ Global replacement of BLACK with WHITE in source code\r\n\t#define BLACK \/\/ Global removal of BLACK from source code\r\n\r\n#undef\r\n\t#undef BLACK \/\/ Stop global replacements of BLACK\r\n\r\n#if\r\n#elif\r\n#else\r\n#endif\r\n\r\n#if defined \r\n\/\/ Same as:\r\n#ifdef\r\n\r\n#if !defined\r\n\/\/ Same as:\r\n#ifndef\r\n\r\n\/\/ Usage:\r\n#ifndef MYHEADER_H\r\n#define MYHEADER_H\r\n#include \"myheader.h\"\r\n#endif\r\n\r\n#line\r\n#error\r\n#pragma\r\n<\/pre>\n
            Using Header Files<\/h3><\/span>\n
            * Ex10_01.h<\/p>\n
            \r\n#include \r\n#ifndef EX10_01_H\r\n#define EX10_01_H\r\nnamespace data\r\n{\r\n  extern const double pi {3.14159265};\r\n  extern const std::string days[] {\r\n                           \"Sunday\", \"Monday\", \"Tuesday\", \"Wednesday\",\r\n                           \"Thursday\", \"Friday\", \"Saturday\"\r\n                                     };\r\n}\r\n#endif\r\n<\/pre>\n
            * Ex10_01.cpp<\/p>\n
            \r\n\r\n#include \r\n#include \r\n#include \"Ex10_01.h\" \/\/ Include the header file\r\n\r\nint main()\r\n{\r\n  std::cout << \"pi has the value \" << data::pi << std::endl;\r\n  std::cout << \"The second day of the week is \" << data::days[1] << std::endl;\r\n}\r\n<\/pre>\n
            Classes<\/h2><\/span>\n
            * Syntax<\/p>\n
            \r\nclass ClassName\r\n{\r\n  private:\r\n  \/\/ Code that specifies members that are not accessible from outside the class\r\n\r\n  protect:\r\n  \/\/ Code that specifies members that are accessible from subclasses\r\n  \r\n  public:\r\n  \/\/ Code that specifies members that are accessible from outside the class\r\n}; \/\/ Note the semicolon here!\r\n<\/pre>\n
            * Constructor<\/p>\n
            \r\n<\/pre>\n
            - using the explicit keyword with constructors that have a single parameter to prevent implicit conversions from the parameter type to the class type<\/p>\n
            \r\nclass Cube\r\n{\r\npublic:\r\n  double side;\r\n\r\n  explicit Cube(double side);               \/\/ Explicit constructor\r\n  double volume();                          \/\/ Calculate volume of a cube\r\n  bool compareVolume(Cube aCube);           \/\/ Compare volume of a cube with another\r\n};\r\n<\/pre>\n
            * Destructor<\/p>\n
            \r\n~Cube() {\r\n  \/\/ Cleanup...\r\n}\r\n<\/pre>\n
            * Accessing member of a class using pointer<\/p>\n
            \r\na->b\r\n\/\/ is equivalent to:\r\n(*a).b\r\n<\/pre>\n
            * this pointer<\/p>\n
            \r\ndouble Box::volume()\r\n{\r\n  return this->length * this->width * this->height;\r\n}\r\n<\/pre>\n
            * Static members of a class<\/p>\n
            * Pointers and references to class objectds<\/p>\n
            * Using Pointers as class members<\/p>\n
            * Example
            \n- Box.h<\/p>\n
            \r\n#ifndef BOX_H\r\n#define BOX_H\r\n#include \r\n#include \r\n\r\nclass Box {\r\n\t\/\/ Private memebers\r\n\tprivate:\r\n\t\tdouble length {1.0};\r\n\t\tdouble width {1.0};\r\n\t\tdouble height {1.0};\r\n\t\r\n\t\/\/ Public members\r\n\tpublic:\r\n\t\t\/\/ ======================= Constructors\r\n\t\t\/\/ Default constructor\r\n\t\tBox() {}\r\n\t\t\r\n\t\t\/\/ Using constructor initialization list\r\n\t\tBox(double lv, double wv, double hv): \r\n\t\t\tlength{lv}, width {wv}, height {hv} {}\r\n\t\t\r\n\t\t\/\/ Copy constructor, use const so we cannot modify object to be copied\r\n\t\tBox (const Box& box) {\r\n\t\t\tlength = box.length;\r\n\t\t\twidth = box.width;\r\n\t\t\theight = box.height;\r\n\t\t}\r\n\r\n\t\t\/\/ ======================= Getters and setters\r\n\t\t\/\/ Getters\r\n\t\tdouble getLength() {return length;}\r\n\t\tdouble getWidth()  {return width;}\r\n\t\tdouble getHeight() {return height;}\r\n\t\t\r\n\t\t\/\/ Setters\r\n\t\tvoid setLength(double lv) { if(lv > 0) length = lv;}\r\n\t\tvoid setWidth(double wv)  { if(wv > 0) width = wv;}\r\n\t\tvoid setHeight(double hv) { if(hv > 0) height = hv; }\r\n\r\n\t\t\/\/ ======================= Methods\r\n\t\tdouble volume() const {\r\n\t\t\treturn length * width * height;\r\n\t\t}\r\n\t\t\r\n\t\tint compare (const Box& box) {\r\n\t\t\tif (volume() < box.volume()) \r\n\t\t\t\treturn -1;\r\n\t\t\t\t\r\n\t\t\tif (volume() == box.volume())\r\n\t\t\t\treturn 0;\r\n\t\t\t\t\r\n\t\t\treturn 1;\r\n\t\t}\r\n\t\t\r\n\t\tvoid listBox() {\r\n\t\t\tstd::cout << \" Box(\" \r\n\t\t\t\t<< std::setw(2) << length << \",\"\r\n\t\t\t\t<< std::setw(2) << width << \",\"\r\n\t\t\t\t<< std::setw(2) << height << \")\";\r\n\t\t}\r\n\t\t\r\n};\r\n#endif\r\n<\/pre>\n
            - Testbox.cpp<\/p>\n
            \r\n#include \r\n#include \"Box.h\"\r\n\r\nint main(){\r\n\tconst Box box1 {2.0, 3.0, 4.0}; \r\n\t\r\n\tstd::cout << \"Volume: \" << box1.volume() << std::endl;\r\n}\r\n<\/pre>\n
            Operator Overloading<\/h2><\/span>\n
            * <\/p>\n
            \r\n<\/pre>\n
            Inheritance<\/h2><\/span>\n
            Polymorphism<\/h2><\/span>\n
            Runtime Errors and Exception<\/h2><\/span>\n
            Class Templates<\/h2><\/span>\n
            File IO<\/h2><\/span>\n
            References<\/h2><\/span>\n
            * Beginning C++ by Ivor Horton
            \n* Book source code<\/a>
            \n*             Standard C++ Library reference<\/a>
            \n*             C++ Standard Library header files<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
            Overview * Latest standard: C++14 * Compile command with Visual Studion command line cl \/EHsc test.cpp * Comments (same as Java and C#): \/\/ this is a comment \/* this is another comment *\/ * Preprocessing directives and header files … Continue reading →<\/span><\/a><\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_exactmetrics_skip_tracking":false,"_exactmetrics_sitenote_active":false,"_exactmetrics_sitenote_note":"","_exactmetrics_sitenote_category":0,"jetpack_post_was_ever_published":false,"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":true,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2}},"categories":[11],"tags":[556],"class_list":["post-12086","post","type-post","status-publish","format-standard","hentry","category-cpp","tag-c"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"jetpack_shortlink":"https:\/\/wp.me\/p8cRUO-38W","_links":{"self":[{"href":"https:\/\/jianmingli.com\/wp\/index.php?rest_route=\/wp\/v2\/posts\/12086","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/jianmingli.com\/wp\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/jianmingli.com\/wp\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/jianmingli.com\/wp\/index.php?rest_route=\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/jianmingli.com\/wp\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=12086"}],"version-history":[{"count":2,"href":"https:\/\/jianmingli.com\/wp\/index.php?rest_route=\/wp\/v2\/posts\/12086\/revisions"}],"predecessor-version":[{"id":12089,"href":"https:\/\/jianmingli.com\/wp\/index.php?rest_route=\/wp\/v2\/posts\/12086\/revisions\/12089"}],"wp:attachment":[{"href":"https:\/\/jianmingli.com\/wp\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=12086"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/jianmingli.com\/wp\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=12086"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/jianmingli.com\/wp\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=12086"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}