Successfully reported this slideshow.
We use your LinkedIn profile and activity data to personalize ads and to show you more relevant ads. You can change your ad preferences anytime.

C++ for Java Developers (SwedenCpp Meetup 2017)

419 views

Published on

Introduction to Modern C++ for programmers with a Java background. Maps key concepts to Java concepts and dives into how C++ programmers deal with and think about memory. This intersection is interesting whether you are learning or teaching C++.

Published in: Software
  • Be the first to comment

  • Be the first to like this

C++ for Java Developers (SwedenCpp Meetup 2017)

  1. 1. @pati_gallardo
  2. 2. C++ for Java Developers @pati_gallardo Patricia Aas SweedenCpp Meetup C++ Stockholm 0x08 2017
  3. 3. Patricia Aas - Vivaldi Browser Programmer - mainly in C++ Currently : Vivaldi Technologies Previously : Cisco Systems, Knowit, Opera Software Master in Computer Science - main language Java Twitter : @pati_gallardo
  4. 4. Let’s Learn some Modern C++ (11-17) @pati_gallardo
  5. 5. Don’t do This! Hero * h = new Hero(); EVER @pati_gallardo
  6. 6. Your First Object #include "Hero.h" int main() { Hero h; } @pati_gallardo
  7. 7. Your First Program #include <iostream> #include <string> int main() { std::string s("Wonder "); std::cout << s << "Woman!"; } @pati_gallardo
  8. 8. Includes - Java Import Including your own headers #include "Hero.h" Including library headers #include <string> @pati_gallardo
  9. 9. Namespaces - Java Packages namespace league { class Hero { }; } @pati_gallardo
  10. 10. league::Hero h; using namespace league; Hero h; Using namespace - Java Import static @pati_gallardo
  11. 11. Using Namespace #include <iostream> #include <string> using namespace std; int main() { string s("Wonder Woman!"); cout << s; } @pati_gallardo
  12. 12. Values, Objects and Referring to them @pati_gallardo
  13. 13. Anything Can Be a Value int main() { Hero b; int meaning = 42; auto pi { 3.14 }; std::string s = "Hi!"; std::mutex my_mutex; } @pati_gallardo
  14. 14. C++ Reference & A C++ reference is not a Java pointer It has to reference an object It is never null It can never reference another object SAFE : Hero & h @pati_gallardo
  15. 15. C++ Pointer * A C++ pointer is not a Java pointer It’s often called a “Raw Pointer” It’s a raw memory address UNSAFE : Hero * h @pati_gallardo
  16. 16. C++ Value In C++ everything is a value, even objects When passed by value it is COPIED* Can only pass-by-value if copying is supported* SAFE : Hero h * Sometimes the original value can be reused @pati_gallardo
  17. 17. Range based For vector<Hero> heroes; for (auto & hero : heroes) hero.rescue(); @pati_gallardo
  18. 18. Const : The Many Meanings class Hero { public: bool canFly() const; void fly(); }; Hero superman; deploy(superman); void deploy(const Hero & h) { if (h.canFly()) // OK h.fly(); //<-- ERROR } @pati_gallardo
  19. 19. const - Related to Final Variables in Java Java final Hero ptr; // ptr is final C++ Hero * const ptr; // ptr is const const Hero * ptr; // object is const const Hero * const ptr; // object+ptr are const @pati_gallardo
  20. 20. Immutable View Of An OBJECT void crisis(const Hero & hero) But the object is mutable - just not by you Mark functions that don’t mutate as const @pati_gallardo
  21. 21. Parameter Passing, Return Values & Lambdas @pati_gallardo
  22. 22. Parameter Passing Pass by const ref : const Hero & hero Pass by reference : Hero & hero Pass by value : Hero hero Pass by pointer - be very careful @pati_gallardo
  23. 23. Auto return type auto meaning() { return 42; } @pati_gallardo
  24. 24. Return by Value Hero experiment() { return Hero(); // return unnamed value } Hero experiment() { Hero h; return h; // return named value } @pati_gallardo
  25. 25. Return Value Optimization Unnamed Return Value Optimization (RVO) Named Return Value Optimization (NRVO) @pati_gallardo
  26. 26. Slicing Copying only parts of an object class FlyingHero : public Hero { int current_altitue = 0 } FlyingHero superman; Hero h = superman; @pati_gallardo
  27. 27. Structured Bindings std::tuple<int, int> point(); auto [x, y] = point(); @pati_gallardo
  28. 28. Lambda and Captures auto meaning = [](){ return 42; }; auto life = 42; auto meaning = [life](){ return life; }; auto meaning = [=](){ return life; }; auto meaning = [&](){ life++; return life;}; @pati_gallardo
  29. 29. Memory : Lifetime & Ownership @pati_gallardo
  30. 30. Where is it? Stack Hero stackHero; Heap unique_ptr<Hero> heapHero = make_unique<Hero>(); Hero * heapHero = new Hero(); @pati_gallardo
  31. 31. Stack - Similar to “Try With Resources” Destroyed when exiting scope Deterministic Garbage Collection @pati_gallardo
  32. 32. Loving the Stack #include <iostream> #include <string> using namespace std; int main() { { string s("Hello World!"); cout << s; } // <- GC happens here! } @pati_gallardo
  33. 33. Hold a Value on the Stack that Controls The Lifetime of Your Heap Allocated Object using namespace std; { unique_ptr<Hero> myHero = make_unique<Hero>(); shared_ptr<Hero> ourHero = make_shared<Hero>(); } Smart Pointers @pati_gallardo
  34. 34. Structure @pati_gallardo
  35. 35. Class Declaration in Header File Class Definition in Cpp File Hero.h & Hero.cpp A header is similar to an interface Function declarations Member variables @pati_gallardo
  36. 36. Classes and Structs @pati_gallardo
  37. 37. No Explicit Root Superclass Implicitly defined member functions Don’t redefine them if you don’t need to The defaults are good Rule-of-zero (Zero except for the constructor) @pati_gallardo
  38. 38. class B { public: // Constructor B(); // Destructor ~B(); // Copy constructor B(const B&); // Copy assignment op B& operator=(const B&); // Move constructor B(B&&); // Move assignment op B& operator=(B&&); }; Implicitly Defined Functions @pati_gallardo
  39. 39. All Classes Are Final by Default By extension : All methods are final by default @pati_gallardo
  40. 40. Virtual Functions Pure virtual - Interface virtual void bootFinished() = 0; Use override void bootFinished() override; @pati_gallardo
  41. 41. Multiple Inheritance is Allowed Turns out the ‘Diamond Problem’ is mostly academic ( and so is inheritance ;) ) @pati_gallardo
  42. 42. All Classes Are “Abstract” Interface : only pure virtual methods Abstract Class : some pure virtual methods Plain Old Class : no pure virtual methods @pati_gallardo
  43. 43. Structs A C++ Struct is a Class Where all members are public by default @pati_gallardo
  44. 44. Static : The Many Meanings “There can be only one” Function in cpp file Local variable in a function Member / function in a class @pati_gallardo
  45. 45. Static member / function in a Class Pretty much the same as Java @pati_gallardo
  46. 46. Static Function in a Cpp File The function is local to the file @pati_gallardo
  47. 47. Static Variable in a Function - Global variable - Only accessible in this function - Same variable across calls Hero heroFactory() { static int num_created_heroes = 0; ++num_created_heroes; return Hero(); } @pati_gallardo
  48. 48. Containers and Standard Types @pati_gallardo
  49. 49. Use std::String - never char * Use : std::string_view Non-allocating, immutable string/substring Note: Your project might have a custom string class @pati_gallardo
  50. 50. Std::Vector Is Great std::vector has great performance Don’t use raw arrays Prefer std::vector or std::array @pati_gallardo
  51. 51. Use std::Algorithms using namespace std; vector<int> v { 1337, 42, 256 }; auto r = find_if(begin(v), end(v), [](int i){ return i == 42; }); @pati_gallardo
  52. 52. @pati_gallardo Segmentation fault (core dumped)
  53. 53. @pati_gallardo

×