struct point {
  int x;  // ← "member variable"
  int y; 
};
// create new object (on stack)
point p {44, 55}; 
// read members' values
cout << p.x <<' '<< p.y;  // 44 55

p.x = 10;
p.y = 20;
cout << p.x <<' '<< p.y;  // 10 20

point u;      // uninitialized
 cout << u.x;  // random value!

void closest_point_on_line(double lx2, double ly1, double lx2i, double ly2, double px, double py, double& cpx, double& cpy) { … }

struct point { double x; double y; };
struct line  { point a; point b; };
point closest_point_on_line(line const& l, point const& p) { … }

Type { arg1, arg2, …, argN }

enum class month {jan = 1, feb = 2,…, dec = 12};
struct date {
  int yyyy;
  month mm;
  int dd;
};
int main() {
  date today {2020, month::mar, 15};	
  // C++98, but also still OK:
  date tomorrow = {2020, month::mar, 16};	
}

enum class month { jan=1, feb=2,… , dec=12 };
struct date {   
  int yyyy;
  month mm;
  int dd;
};
struct person {
  std::string name;
  date bday;
};
int main() {
  person jlp { "Jean-Luc Picard",              {2305, month::jul, 13} };
  cout << jlp.name;     // Jean-Luc Picard
  cout << jlp.bday.dd;  // 13
  date yesterday { 2020, month::jun, 16 };
  person rv = { "Ronald Villiers", yesterday };
}

enum class month {jan = 1, … };
struct date { 
  int yyyy;  month mm;  int dd; 
};
int main() {
  date a {2020, month::mar, 7};     
  date b = a;  // deep copy of a
  b.dd = 22;   // change b
}

struct point { int x; int y; };
point p1 {1, 2};  // construction
point p2 = p1;    // copy construction
point p3 ( p1 );  // copy construction
point p4 { p1 };  // copy construction
auto  p5 = p1;    // copy construction
auto  p6 ( p1 );  // copy construction
auto  p7 { p1 };  // copy construction
p3 = p2;  // copy assignment
          // (both p2 & p3 existed before)

Value Semantics

= variables refer to objects themselves:

• deep copying: copies refer to different objects; (member) values are copied
• deep assignment: target replicates source object's value
• deep ownership: member variables refer to objects with same lifetime as containing object
• value-based comparison: variables compare equal if their values are equal

Value semantics is the default behavior for fundamental types (int, double, etc.) in almost all programming languages and also the default for aggregates/user-defined types in C++ (and Rust).

---

Reference Semantics

= variables are referencs to objects:

• shallow copying: copies of a variable refer to the same object
• shallow assignment: assignment makes a variable reference a different object
• shallow ownership: member variables are also just references
• identity-based comparison: variables compare equal if they refer to the same object

Most other mainstream languages (Java, Python, C#, Swift, …) use (baked-in) reference semantics for user-defined types.

---

The situation in C++ is consistent and offers full control:

• default: value semantics for all types
• optional reference semantics possible for all types (by using references or pointers)

vector<int> v { 0,1,2,3,4 };

struct p2d { int x; int y; };
vector<p2d> v {{1,2},{5,6},{8,9}};

struct A { … };
A a ();  // declares function 'a' 
         // without parameters
         // and return type 'A'
A a;     // constructs an object of type A
A a {}   // constructs an object of type A