CS 450 Notes Chapter 2

Introduction
- Class definitions
  A class is like a structure but it includes fields that are functions. Some of the fields are public and some are private. Private functions and data are only available to functions inside the class. Public functions and data are available to outside code. Try to put the public stuff first. Makes it clearer what the user can use. Need member functions to read and set the private data as outside functions won't be able to.
```
	class list {
	public:
	private:
	}; // list
	
```
  class and struct are almost interchangable. in a class, the default is private. In a struct, the default is public. If use don't use the keywords, all methods are public and all data is private. The above is the declaration of a class.
```
	list joe;
	
```
  is the definition of an instance called joe. Each instance of a class has a new instantiation of the private variables. If a private variable is declared static, then all the instances share the value of that variable.
- Functions and Member functions
  Functions must be declared before use. Could be in class definition or simple prototypes.
  - Overloading
    Function names and operators can be overloaded. That is, multiple versions of a function can exist with the same name. They are usually differentiated by the arguments. Operators like + can also be overloaded. They get turned into a function call with the operand(s) as arguments. Overloading can be used in functions that aren't part of a class.
  - Constructors
    Called when a variable of that type is declared. Has the same name as the class. Usually several are defined. The simplest takes no args, others take args to help in initialization. The constructor without args is called the default constructor. The default constructor is used when arrays of a class are defined.
  - Destructors
    Called when an instance of a class goes out of scope. This means it can't be seen anymore and so can be destroyed. The destructor de-allocates storage and any other housekeeping needed. It is called implicitly.
  - Member functions (methods)
    Defined either inline in the class definition or outside. The outside member functions must indicate the class they are part of. The 'Class_name::' part is called the scope resolution operator It tells the compiler that this function is part of the class class_name.
```
		Return type
		Class_name::function_name
	
```
    Member functions don't have to specify the private members of the class. For example, in the C version of a function that examined the value of an element in a structure, the structure was passed as a pointer to the function.
```
	void
	foo(struct martha * one) {
	   printf("%d",one->item);
	}
	
```
    In C++, the pointer is implicit and the elements can be simple variables in the private part of the class. so
```
	void
	foo() {
	   printf("%d",item);
	}
	
```
    item can be treated as a parameter to the function. There is a pointer to the data in the class instance avaliable called this. So the variable above was useable as
```
	this->item;
	
```
  - Inline definition
    Putting inline in front of a function definition causes the compiler to generate inline code rather than a function call. Sometimes it can't. Code should be faster but bigger.
  - Default parameters
    The arguments to a function can have default values. In this case, if the actual value is missing, the default is used.
```
		Foo(int s,int n=3);
	
```
    This can be called as either
```
		Foo(12);
		Foo(12,9);
	
```
    In the first case, the value of n in the function is 3. In the second, it is 9. Only the last parameters in the definition can be defaulted. All parameters after a default parameter must be default as well. Default parameters are only put in the function declaration, not the definition. So the above would be:
```
	class nyarf {
	public:
	int foo(int s,int n=3);
	};
	int
	nyarf::foo(int s,int n);
	
```
    The default value can be mentioned in the definition via a comment.
```
		foo(int n,int,float x);
	
```
    The second parameter can be passed, but cannot be referred to in the function. Can be used as aplaceholder for future growth in parameters or as a way to stop using a parameter and prevent warnings without changing the calling code. An extension of this is that function definitions in C++ don't need an identifier.
```
	int
	nyarf::foo(int s,int n /* = 3 */);
	
```