CIS 3142 — Default Operations for a Class

CISC 3142
Programming Paradigms in C++
Default Operations for a Class

Overview

When a class is defined, several operations are provided — automatically and implicitly — by the compiler. This is done for several reasons:

The intuitive, default semantics of these operations 'make sense' and are correct in many, if not most situations, and can be inferred by the compiler
- for example, our intuitive sense of initializing an integer with another integer is to copy the value of the source to the destination of the data members
```
int i = 17;
…
int j = i;	// copy the value of i to j
				
```
- In a similar manner, our intuitive sense of using an object of a class to initialize another object of a class it to perform a memberwise copy of each data member of the source object to the destination object
```
class C {
	…
private:
	int i;
	double d;
	int arr[100];
	int *ip;
};
…
C c1(…);
C c2 = c1;		// copy the data members of c1 to c2
				
```
  - furthermore, the compiler can figure out how to do this on its own (it knows the data members and their types)
the implementation of the operation is 'tedious and/or error-prone', and thus the compiler can often do a better job than the programmer
- The programmer may forget to include a data member in their initialization list; compilers don't make mistakes like this
```
class C {
	C(const C &c) : capacity(c.capacity), arr(new int[c.capacity]) {…}	// ooops … forgot to set size to 0
private:
	int *arr;
	int capacity, size;
};
				
```
Although these operations may not be simple to understand or implement for a novice, they arise in even trivial programs
- Passing a class object by value involves creating a new parameter object and copying over the value of the argument; this requires a copy constructor.
  - One could either start teaching references and call by reference, or teach how to write a copy constructor; neither option is desireable in the first week of an intro class

The Core Concept Behind Providing Default Operations

In essence — within the context of initialization, copying, moving, and cleanup — and in the absence of an explicit function provided by the class designer, the compiler attempts to do the 'right thing', i.e., what would be expected, i.e., at the very least mimic what would happen with a fundamental type, and if possible go beyond that depending on the nature of the data members (e.g. class object with their own constructors, copy constructors, etc)..

A Preliminary Word About Constructors

Constructors can be thought of falling into two distinct categories: application-specific and application-independent:

application-specific constructors accept argument that are relevant to the semantics of the class, e.g., a Person class might accept a Name object and an age integer as its constructor arguments; or a Rational class would accept numerator and denominator arguments to its constructor. Such constructors would not carry over from class to class — the information passed to the constructor is specific to the class' application space.
application-independent constructors do not deal with the semantics of the application; their semantics is at the level of the class construct and carries over — at least to some degree — from class to class. The primary (sole?) example of this is the copy constructor that accepts an object of the same class as its argument, and whose function is to initialize the new object with the arguments values. This notion is essentially the same for each class.
The default constructor, in some sense, falls into neither class — at least from the perspective of the user — as no information, application-specific or -independent, is supplied as argument.

Finally, remember that the whole point of the constructor is to initialize the object so that it is in a valid state vis-a-vis the semantics of the class (Stroustrup speaks of the constructor enforcing or establishing an invariant). The set of constructors comprises the ONLY way a user can initialize an object of the class; i.e., if the Rational class only supplied the 2-arg constructor, one could not create Rational with only a numerator, or NO arguments, regardless of whether such initialization would make sense. In other words, the only legal initialization of the object is what the constructor designers offer.

The Default Operations

First a clarifying note … the term default operation is not the same as default constructor:

A default operation is an operation (i.e., function) supplied by the compiler in the absence of one provided by the class designer
A default constructor is a constructor that takes no arguments, thus allowing an object of that class to be created without the user providing (or even having to know about) any further information.
- to add to the confusion, the default constructor is one of the default operations of a class, as discussed below

Again, the idea of a default operation is that it is something the compiler can provide on its own — usually (but not always) with correct semantics.

Note: for this discussion, we're assuming a class C.

Default Constructor (`C()`)

A default constructor allows the user to leave the details of the initialization completely up to the class designer.
Let us use the term compiler-generated default constructor to refer to the default constructor provided by the compiler
A compiler-generated default constructor generated by the compiler has no knowledge of the semantics of the class, and thus is quite limited in what it can do. The intuitive sense is that is does what it can, without sacrificing performance, i.e., it calls the default constructors (assuming there is one) of data members that are class objects; fundamental-type data members remain uninitialized.
Such a constructor only makes sense if the class designer has not supplied ANY constructors for the class.
- This is in accordance with the above discussion. The set of constructors limits the user to the way in which an object of the class can be initialized. If the class designer supplied some other constructor, and not a default constructor, it means that the designer does not want object initialized by default
```
class Person {
public:
	Person(const Name &name, int age);
	…
};
			
```
  it is clear that the designer of Person requires a Name and age in order to initialize a Person object. Furthermore, had they wiished a default initialization be permitted, they would have supplied a default constructor.
If the class designer provides a default constructor, it can have any semantics/logic they want, and like the presence of any other constructor suppresses the default default constructor

Copy Constructor (`C(const C &)`)

as mentioned above, the compiler provides a (compiler-generated) copy constructor, so the user doesn't have to
the copy constructor is invoked whenever an object of the class is created and initialized with an object of the same class
- declaration with an initializer
```
C c1(…);
C c2 = c1;
				
```
- call-by-value
```
void f(C c);
…
C c1(&hellip_;
…
f(c1);
				
```
- return-by-value
```
C f();
…
C c1(&hellip_;
…
c1 = f();
				
```
note the signature of the copy constructor; in this instance, it is not merely good practice to pass by const-reference — is it absolutely necessary — passing by-value would cause an infinite recursive runaway.
the intuitive sense of what the copy constructor should do is member-wise copy of all data members

if one or more of the data members are pointers and a deep copy is necessary, the default copy constructor is insufficient and the class designer must supply one of their own

class C {
	C(int capacity) : capacity(capacity), arr(new int[capacity]), soze(0) {}
	…
private:
	int *arr;
	int capacity, size;
};
…
C c1(…);
…
C c2 = c1;		// memberwise copy will only copy the pointer (shallow copy), we probably want to make a copy of the dynamic array

Assignment Operator (`C & operator =(const C &)`)

the assignment operator is semantically related to the copy constructor
- the main difference is the copy constructor initializes a newly created object, which the assignment operator assigns to an already-existing object
  - We'll the discuss the implications later, the basic notion is that the existing object may be holding resources (i.e., dynamically allocated memory) that needs to be released

Destructor

the idea here is similar to that of the default constructor (where the default default constructor invoked the default constructor of any data member) — we want to make sure that any destructors of data members get called.

Again, any of the above functions that are supplied by the class designer (and they usually come as a group), suppress the corresponding compiler-supplied default.

CISC 3142 Programming Paradigms in C++ Default Operations for a Class

Overview

The Core Concept Behind Providing Default Operations

A Preliminary Word About Constructors

The Default Operations

Default Constructor (C())

Copy Constructor (C(const C &))

Assignment Operator (C & operator =(const C &))

Destructor

Code Used in this Lecture

CISC 3142
Programming Paradigms in C++
Default Operations for a Class

Default Constructor (`C()`)

Copy Constructor (`C(const C &)`)

Assignment Operator (`C & operator =(const C &)`)