> For the complete documentation index, see [llms.txt](https://lauradang.gitbook.io/notes/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://lauradang.gitbook.io/notes/c++/cs_246/lecture-9.md).

# Lecture 9

### Class

* Big innovation in OOP
* Can put functions inside a struct

**Example:**

```
// file: student.h

#ifndef STUDENT_H
#define STUDENT_H

struct student {
  int assns, mt, final;
  float grade(); // forward declaration
};

// file: student.cc

#include "student.h"
float Student::grade() { // veru similar to std::
return this->assns*0.5+this->mt*0.2+this->final*0.4;
}

Student billy {70, 50, 75};
Student billy = {70, 50, 75};
billy.grade();
```

**Class**: A struct that contains functions

* every C++ struct can contain functions
* An instance/value of a class is called an object
  * I.e. Billy is an object

**Member**: Function within a class

* eg. grade(); //invalid
* Must use object to call a method
* methods are called on objects
* Within method call, method has access fields of the object

**Methods**

* have hidden parameter
  * "this"
  * "this" points to object used to call method eg.

```
this == &billy => (*this == billy)
this->assns == (*this).assns
```

**Style Initialization**:

```
student billy {70,50,75};
```

* requires "parameters" to be compile time constant
* C++ allows special methods called **constructors** to construct objects

**Example:**

```
// file: student.h

struct Student {
  int assns, my, final;
  ...
  Student(int assns, int mt, int final); // constructor - same name as class
};

// file: student.cc

Student::student(int assns, int mt, int final);
this->assns=assns;
this->mt=mt;
this->final=final;
```

**Compare**:

```
// Initializing using constructor
// constructor has 3 ints in parameters, so this works
Student billy {70,50,75}; // goes to c-style intialization if no constructor


// Initializing without constructor
// if constructor does not take any arguments, then you would do this
Student billy = {70,70,75};

// Putting "billy" on the heap, not the stack

Student *pbilly = new Student {70, 50, 75};
delete pbilly;
```

**Advantages of Constructors**:

* args do not need to be constants
* method overloading (different parameters)
* ctor body can execute any code
  * ex. sanity checks
* default args

**Example:**

```
// file: student.h

struct Student {
  Student(int assns=0, int mt=0, int final=0); // default value in header file only
}

// file: student.cc
Student::Student(int assns, int mt, int final) {
this->assns = assns < 0? 0:assns;
this->mt = mt < 0? 0:mt;
this->final = final < 0? 0:final;
}

Student s2 {80, 60}; // final=0
Student s3 {75}; // mt=final=0
Student s4 {}; // mt=final=assns=0
Student s4;

int main() {
  // requires a 3 parameter constructor
  // (only available when program is running, cannot do c-style intialization => not constants)
  int x,y,z;
  cin >> x >> y >> z;
  Student s {x, y, z};
}
```

### Default Constructor

Every class comes with a default ctor

* ctor with 0 parameters
* calls default ctors on fields that are objects **Example**

```
struct MyStruct {
  int x;  // calls default ctor
  Student y;  // x, p will not be initialized
  Vec *p; // y has been initialized
};
```

* ctor body -> too late to initialize constant
* Hijack step 2 to intialize constants/references
* MIL: Members Initialization List


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://lauradang.gitbook.io/notes/c++/cs_246/lecture-9.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.