This document outlines a presentation by Patricia Aas on modern C++ concepts for Java developers, focusing on various topics such as memory management, value vs. reference semantics, and C++ language features. It includes code examples, discussions on classes and structs, pointers, containers, and smart pointers. The aim is to help Java developers adapt to C++ programming through familiar concepts and best practices.

1. @pati_gallardo

2. C++ for Java Developers
@pati_gallardo Patricia Aas
JavaZone Academy - Tromsø 2018

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. Let’s Learn some Modern C++ (11-17)
@pati_gallardo

5. Don’t do This!
Hero * h = new Hero();
EVER
@pati_gallardo

6. - Hello World
- Values, Objects and Referring to
them
- Parameter Passing, Return
Values & Lambdas
- Memory : Lifetime & Ownership
- Structure : Classes and Structs
- Containers and Standard Types
@pati_gallardo

7. Your First Object
#include "Hero.h"
int main()
{
Hero h;
}
@pati_gallardo

8. Your First Program
#include <iostream>
#include <string>
int main()
{
std::string s("Wonder ");
std::cout << s << "Woman!";
}
@pati_gallardo

9. Includes - Java Import
Including your own headers
#include "Hero.h"
Including library headers
#include <string>
@pati_gallardo

10. Namespaces - Java Packages
namespace league {
class Hero {
};
}
@pati_gallardo

11. league::Hero h;
using namespace league;
Hero h;
Using namespace - Java Import static
@pati_gallardo

12. Using Namespace
#include <iostream>
#include <string>
using namespace std;
int main()
{
string s("Wonder Woman!");
cout << s;
}
@pati_gallardo

13. Values, Objects and Referring to them
@pati_gallardo

14. 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

15. 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

16. 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

17. 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

18. Range based For
vector<Hero> heroes;
for (auto & hero : heroes)
hero.rescue();
@pati_gallardo

19. 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

20. 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

21. 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

22. Parameter Passing, Return Values & Lambdas
@pati_gallardo

23. 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

24. Auto return type
auto meaning() { return 42; }
@pati_gallardo

25. Return by Value
Hero experiment() {
return Hero(); // return unnamed value
}
Hero experiment() {
Hero h;
return h; // return named value
}
@pati_gallardo

26. Return Value Optimization
Unnamed Return Value Optimization (RVO)
Named Return Value Optimization (NRVO)
@pati_gallardo

27. Slicing
Copying only parts of an object
class FlyingHero : public Hero {
int current_altitue = 0
}
FlyingHero superman;
Hero h = superman;
@pati_gallardo

28. Structured Bindings
std::tuple<int, int> point();
auto [x, y] = point();
@pati_gallardo

29. 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

30. Memory : Lifetime & Ownership
@pati_gallardo

31. Where is it?
Stack
Hero stackHero;
Heap
unique_ptr<Hero> heapHero =
make_unique<Hero>();
Hero * heapHero = new Hero();
@pati_gallardo

32. Stack - Similar to “Try With Resources”
Destroyed when exiting scope
Deterministic Garbage Collection
@pati_gallardo

33. Loving the Stack
#include <iostream>
#include <string>
using namespace std;
int main()
{
{
string s("Hello World!");
cout << s;
} // <- GC happens here!
}
@pati_gallardo

34. 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

35. Structure
@pati_gallardo

36. 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

37. Classes and Structs
@pati_gallardo

38. 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

39. 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

40. All Classes Are Final by Default
By extension :
All methods are final by default
@pati_gallardo

41. Virtual Functions
Pure virtual - Interface
virtual void bootFinished() = 0;
Use override
void bootFinished() override;
@pati_gallardo

42. Multiple Inheritance is Allowed
Turns out
the ‘Diamond Problem’ is mostly academic
( and so is inheritance ;) )
@pati_gallardo

43. All Classes Are “Abstract”
Interface : only pure virtual methods
Abstract Class : some pure virtual methods
Plain Old Class : no pure virtual methods
@pati_gallardo

44. Structs
A C++ Struct is a Class
Where all members are public by default
@pati_gallardo

45. 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

46. Static member / function in a Class
Pretty much the same as Java
@pati_gallardo

47. Static Function in a Cpp File
The function is local to the file
@pati_gallardo

48. 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

49. Containers and Standard Types
@pati_gallardo

50. 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

51. Std::Vector Is Great
std::vector has great performance
Don’t use raw arrays
Prefer std::vector or std::array
@pati_gallardo

52. 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

53. @pati_gallardo
Segmentation fault (core dumped)

54. Make Everyone Feel Safe To Be Themselves
@pati_gallardo

55. Vivaldi Swag
Patricia Aas, Vivaldi Technologies
@pati_gallardo
Photos from pixabay.com

56. @pati_gallardo