Classes¶

Time Complexity	Space Complexity
N/A	N/A

Note

This page goes over how to implement a class in code. For the concept of what classes are about, see Object Oriented Programming.

A “class” is the name given to an “object” (thing), or type, definition in code. Classes are how you describe data that doesn’t fit into primitive (basic) types such as “int” or “float”. “String” is an example of a class; somewhere in the language code, the string type is defined, and how it interacts with other types and other operations it performs are defined in “member variables” and “member functions”. “Member variables” hold data pertaining to the object, like the different characters in a string. “member functions” define functions the object can perform, such as combining with other strings.

Classes are useful for organizational purposes; instead of making a lot of variables and many different functions, you can define which variables and functions are associated with which object. Here is an example class “person”, with one “member variable” (a “name”) and one “member function” (“sayHi”), along with a definition of how the object (thing) is declared:

#include <iostream>
#include <string>
using namespace std;

class person{

  string name;

  public:

  person(){
    name = "Tim Apple";
  }
  person(string inputName){
    name = inputName;
  }
  // or
  //   person(string inputName = "Tim Apple"){
  //     name = inputName;
  //   }
  // or
  //   person(string inputName = "Tim Apple") : name(inputName) {}

  void sayHi(){
    cout << "Hi, my name is " + name + "." << endl;
  }
};

int main(){

  person Tim;
  person Jeff("Jeff");

  Tim.sayHi();
  Jeff.sayHi();

  return 0;
}

class Program {
  public class person{
    private string name;

    public person(){
      name = "Tim Apple";
    }
    public person(string inputName = "Tim Apple"){
      name = inputName;
    }
    // or
    // public person(string inputName = "Tim Apple"){
    //   name = inputName;
    // }

    public void sayHi(){
      System.Console.WriteLine("Hi, my name is " + name + ".");
    }
  }
  static void Main(string[] args)
  {
    person Tim = new person();
    person Jeff = new person("Jeff");

    Tim.sayHi();
    Jeff.sayHi();
  }
}

public class classes {
  public static class person{
    private String name;

    public person(){
      name = "Tim Apple";
    }
    public person(String inputName){
      name = inputName;
    }

    public void sayHi(){
      System.out.println("Hi, my name is " + name + ".");
    }
  }
  public static void main(String[] args) {
    person Tim = new person();
    person Jeff = new person("Jeff");

    Tim.sayHi();
    Jeff.sayHi();
  }
}

function person(inputName){
  if (typeof(inputName) === 'undefined'){
    this.name = "Tim Apple";
  }else{
    this.name = inputName;
  }
}
person.prototype.sayHi = function sayHi(){
  console.log("Hi, my name is " + this.name + ".");
}

var Tim = new person();
var Jeff = new person("Jeff");

Tim.sayHi();
Jeff.sayHi();

class person{
  constructor(inputName = "Tim Apple"){
    this.name = inputName;
  }
  sayHi(){
    console.log("Hi, my name is " + this.name + ".");
  }
}
var Tim = new person();
var Jeff = new person("Jeff");

Tim.sayHi();
Jeff.sayHi();

class person:
  name = None
  def __init__(self,inputName = "Tim Apple"):
    self.name = inputName
  def sayHi(self):
    print("Hi, my name is " + self.name + ".")

Tim = person()
Jeff = person("Jeff")

Tim.sayHi()
Jeff.sayHi()

class person{
  var name: String

  init(_ name: String = "Tim Apple"){
    self.name = name
  }

  func sayHi(){
    print("Hi, my name is " + self.name + ".")
  }
}

let Tim = person()
let Jeff = person("Jeff")

Tim.sayHi()
Jeff.sayHi()

Notes¶

The line #include <string> is needed to use strings.

The line public: is needed so that the class members following that keyword are accessible outside the class definition. Everything before that is set to private by default because it is a class, making them inaccessible.

The functions that have the class name and no type (person(...) here) are called “constructors”. They let you change the values in the class when declaring an object from it. The constructor being used has one definition with no variables and one definition with one variable (the name); this is so the object can be made with or without the variable (this is also called “function overloading”).

A constructor with a default for the parameter, as well as a constructor with an “initialization list” on top of that, are given as examples directly following that. They are a sort of shorthand for the constructor that is not commented out, and they do the same thing.

Classes in C++ need to be declared before they are used; the compiler reads sequentially. For instance, if the class person was declared after the main function, there would be an error because there was no definition for person yet. Typically, classes are put in a seperate “header” file to avoid this.