FilesExpand file tree

master

/

rvalue.cpp

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

121 lines (101 loc) · 2.02 KB

master

/

rvalue.cpp

Copy path

Top

File metadata and controls

• Code
• Blame

121 lines (101 loc) · 2.02 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

#include <iostream>

using namespace std;

class Foo {

public:

Foo() : n(0) {

cout << "Foo()\n";

}

~Foo() {

cout << "~Foo()\n";

}

Foo (const Foo& rhs) : n(rhs.n) {

cout << "Foo(Foo&)\n";

}

Foo& operator= (const Foo& rhs) {

cout << "operator=\n";

n = rhs.n;

return *this;

}

int n;

};

Foo createValue(int n) {

Foo f;

f.n = n;

return f;

}

Foo& createRef(int n) {

static Foo f;

//Foo f;

f.n = n;

return f; // returning stack variable by ref, but do anyway for example

}

void foo_examples() {

{

cout << "1\n";

Foo f1;

}

{

cout << "2\n";

Foo f1;

Foo f2 = f1;

}

{

cout << "3\n";

// NOTE: only single Foo is constructed and destroyed

Foo f3 = createValue(2);

}

{

cout << "4\n";

// NOTE: only single Foo is constructed and destroyed

// calls Foo(), ~Foo(), Foo(Foo&), ~Foo()

Foo f3 = createRef(3);

}

}

class Bar {

public:

Bar() {

cout << "Bar()\n";

own = true;

}

~Bar() {

cout << "~Bar(own=" << own << "))\n";

}

Bar(const Bar& rhs) { // normal copy constructor

cout << "Bar(const Bar&)\n";

own = false;

}

Bar(Bar&& rhs) { // move constructor

cout << "move Bar(const Bar&&)\n";

rhs.own = false;

own = true;

}

Bar& operator= (const Bar&) { // normal assignment operator

cout << "operator=\n";

return *this;

}

Bar& operator= (Bar&& rhs) { // move assignment operator

cout << "move operator=\n";

if (this != &rhs) {

own = rhs.own;

rhs.own = false;

}

return *this;

}

bool own;

};

Bar getBarValue() {

Bar b;

return b;

}

void bar_examples() {

cout << "b1:\n";

Bar b1;

Bar b2(b1);

Bar b3 = getBarValue();

}

int main(int argc, const char *argv[])

{

foo_examples();

bar_examples();

return 0;

}