Föreläsningsanteckningar OOP-föreläsning 10, tisdag 9 oktober 2007
==================================================================

Idag
====

1. En vektorklass med flyttal
2. Kort: En vektor-"klass" i C
3. Kort: Nästan samma vektorklass, men i form av en mall (template)
4. Standardbibliotekets vektorklass, "vector"
5. Egna typkonverteringar: operator double
6. Kl 11:45: Information om SDU2-kursval



1. En vektorklass med flyttal
=============================

Vektor.h
--------

#ifndef VECTOR_H
#define VECTOR_H

class Vektor {
private:
  double* lagring;
  int storlek;
public:
  Vektor(int storlek);
  Vektor(const Vektor& original);
  ~Vektor();
  const Vektor& operator=(const Vektor& original);
  void set(int position, double nytt_varde);
  double get(int position);
  double& operator[](int position);
};

#endif



Vektor.cpp
----------

#include <iostream>
#include <cassert>
using namespace std;
#include "Vektor.h"

Vektor::Vektor(int storlek) {
  this->storlek = storlek;
  lagring = new double[storlek];
}

Vektor::Vektor(const Vektor& original) {
  this->storlek = original.storlek;
  this->lagring = new double[original.storlek];
  for (int i = 0; i < original.storlek; ++i)
    this->lagring[i] = original.lagring[i];
}

Vektor::~Vektor() {
  delete [] lagring;
}

void Vektor::set(int position, double nytt_varde) {
  this->lagring[position] = nytt_varde;
}

double Vektor::get(int position) {
  return this->lagring[position];
}

double& Vektor::operator[](int position) {
  return this->lagring[position];
}

const Vektor& Vektor::operator=(const Vektor& original) {
  if (this != &original) {
    double* ny_lagring = new double[original.storlek];
    for (int i = 0; i < original.storlek; ++i)
      ny_lagring[i] = original.lagring[i];
    delete [] this->lagring;
    this->storlek = original.storlek;
    this->lagring = ny_lagring;
  }
  return *this;
}



main.cpp
--------

#include <iostream>
#include <cassert>
using namespace std;
#include "Vektor.h"

int main() {
  Vektor v1(3);
  Vektor v2 = 7;
  Vektor v3 = v1;

  v2 = v1;
  v1 = v1;

  v1.set(2, 3.14);
  cout << "v1.get(2) = " << v1.get(2) << endl;

  v1[2] = 3.15;
  cout << "v1[2] = " << v1[2] << endl;

  return 0;
}



Makefile
--------

CCC = g++
CPPFLAGS += -Wall

vektor: Vektor.o Vektor.h main.o
	$(CCC) $(CFLAGS) $(CPPFLAGS) -o vektor main.o Vektor.o



2. Kort: En vektor-"klass" i C
==============================

vektor.h
--------

#ifndef VEKTOR_H
#define VEKTOR_H

struct Vektor {
  double* lagring;
  int storlek;
};

typedef struct Vektor Vektor;

extern void vektor_init(struct Vektor* this, int storlek);
extern void vektor_copy(struct Vektor* this, struct Vektor* original);
extern void vektor_cleanup(struct Vektor* this);
extern double vektor_get(struct Vektor* this, int pos);
extern void vektor_set(struct Vektor* this, int pos, double value);

#endif



vektor.c
--------

#include <stdlib.h>
#include "vektor.h"

void vektor_init(struct Vektor* this, int storlek) {
  this->storlek = storlek;
  this->lagring = malloc(storlek * sizeof(double));
}

void vektor_cleanup(struct Vektor* this) {
  free(this->lagring);
}

double vektor_get(struct Vektor* this, int pos) {
  return this->lagring[pos];
}

void vektor_set(struct Vektor* this, int pos, double value) {
  this->lagring[pos] = value;
}



main.c
------

#include <stdlib.h>
#include <stdio.h>
#include "vektor.h"

int main() {
  Vektor v;
  vektor_init(&v, 3);

  vektor_set(&v, 0, 7.1);
  vektor_set(&v, 2, 5.9);

  printf("v[0] == %f\n", vektor_get(&v, 0));
  printf("v[1] == %f\n", vektor_get(&v, 1));

  vektor_cleanup(&v);
  return 0;
}



3. Kort: Nästan samma vektorklass, men i form av en mall (template)
===================================================================

Vektor.h
--------

#ifndef VECTOR_H
#define VECTOR_H

template <class T> class Vektor {
private:
  T* lagring;
  int storlek;
public:
  Vektor(int storlek);
  Vektor(const Vektor& original);
  ~Vektor();
  const Vektor& operator=(const Vektor& original);
  void set(int position, T nytt_varde);
  T get(int position);
  T& operator[](int position);
};

template <class T> Vektor<T>::Vektor<T>(int storlek) {
  this->storlek = storlek;
  lagring = new T[storlek];
}

template <class T> Vektor<T>::Vektor<T>(const Vektor<T>& original) {
  this->storlek = original.storlek;
  this->lagring = new T[original.storlek];
  for (int i = 0; i < original.storlek; ++i)
    this->lagring[i] = original.lagring[i];
}

template <class T> Vektor<T>::~Vektor<T>() {
  delete [] lagring;
}

template <class T> void Vektor<T>::set(int position, T nytt_varde) {
  this->lagring[position] = nytt_varde;
}

template <class T> T Vektor<T>::get(int position) {
  return this->lagring[position];
}

template <class T> T& Vektor<T>::operator[](int position) {
  return this->lagring[position];
}

template <class T> const Vektor<T>& Vektor<T>::operator=(const Vektor<T>& original) {
  if (this != &original) {
    T* ny_lagring = new T[original.storlek];
    for (int i = 0; i < original.storlek; ++i)
      ny_lagring[i] = original.lagring[i];
    delete [] this->lagring;
    this->storlek = original.storlek;
    this->lagring = ny_lagring;
  }
  return *this;
}

#endif



main.cpp
--------

#include <iostream>
#include <cassert>
using namespace std;
#include "Vektor.h"

int main() {
  Vektor<double> v1(3);
  Vektor<double> v2 = 7;
  Vektor<double> v3 = v1;

  v2 = v1;
  v1 = v1;

  v1.set(2, 3.14);
  cout << "v1.get(2) = " << v1.get(2) << endl;

  v1[2] = 3.15;
  cout << "v1[2] = " << v1[2] << endl;

  return 0;
}



4. Standardbibliotekets vektorklass, "vector"
=============================================

main.cpp
--------

#include <iostream>
#include <cassert>
#include <vector>
using namespace std;

int main() {
  vector<double> v1(3);
  vector<double> v2(7);
  vector<double> v3 = v1;

  v2 = v1;
  v1 = v1;

  v1.at(2) = 3.14;
  cout << "v1.at(2) = " << v1.at(2) << endl;

  v1[2] = 3.15;
  cout << "v1[2] = " << v1[2] << endl;

  return 0;
}


5. Egna typkonverteringar: operator double
==========================================

komplex-3.cpp
-------------

#include <iostream>

using namespace std;

class KOMPLEX {
private:
  double re, im;
public:
  KOMPLEX(double re, double im);
  KOMPLEX();
  KOMPLEX operator+(KOMPLEX k2);
  KOMPLEX operator-(KOMPLEX k2);
  KOMPLEX operator*(KOMPLEX k2);
  KOMPLEX operator/(KOMPLEX k2);
  operator double();
  operator int();
  friend ostream& operator<<(ostream& ut, KOMPLEX& p);
};

KOMPLEX::KOMPLEX(double re, double im) {
  this->re = re;
  this->im = im;
}

KOMPLEX::KOMPLEX() {
  this->re = 0;
  this->im = 0;
}

KOMPLEX KOMPLEX::operator+(KOMPLEX k2) {
  KOMPLEX temp;
  temp.re = this->re + k2.re;
  temp.im = this->im + k2.im;
  return temp;
}

KOMPLEX KOMPLEX::operator-(KOMPLEX k2) {
  KOMPLEX temp;
  temp.re = this->re + k2.re;
  temp.im = this->im + k2.im;
  return temp;
}

KOMPLEX KOMPLEX::operator*(KOMPLEX k2) {
  // ...
}

KOMPLEX KOMPLEX::operator/(KOMPLEX k2) {
  // ...
}

KOMPLEX::operator double() {
  return re;
}

KOMPLEX::operator int() {
  return (int)re;
}

ostream& operator<<(ostream& ut, KOMPLEX& k) {
  if (k.im < 0)
    cout << "(" << k.re << " - " << -k.im << "i)";
  else
    cout << "(" << k.re << " + " << k.im << "i)";
  return cout;
}

int main() {
  KOMPLEX z(1.13, 0.9);
  cout << "z = " << z << endl;
  cout << "(double)z = " << (double)z << endl;
  cout << "(int)z = " << (int)z << endl;

  double d;
  d = (double)z;
  cout << "d = " << d << endl;
  d = z;
  cout << "d = " << d << endl;
  int i;
  i = (int)z;
  cout << "i = " << i << endl;
  i = z;
  cout << "i = " << i << endl;
}



Utmatning
---------

z = (1.13 + 0.9i)
(double)z = 1.13
(int)z = 1
d = 1.13
d = 1.13
i = 1
i = 1


(Vad händer om man tar bort operator int?)



6. Kl 14:45: Information om SDU2-kursval
========================================