[[oktatas:programozás:cpp|< CPP]]

====== CPP Objektum Orientált Programozás ======

  * **Szerző:** Sallai András
  * Copyright (c) Sallai András, 2011, 2014
  * Licenc: [[https://creativecommons.org/licenses/by-sa/4.0/|CC Attribution-Share Alike 4.0 International]]
  * Web: https://szit.hu
===== Struktúra =====

A C++ nyelvben a struktúrákban már az osztályok is meghatározhatók:

<code c++ program01.cxx>
#include <iostream>

using namespace std;

struct Dolgozo {
	string nev;
	void beallitNev(string ujNev) {
		nev = ujNev;
	}
	string lekerNev() {
		return nev;
	}
};

int main(int argc, char **argv) {
	Dolgozo mari;
	mari.beallitNev("Nagy Mária");
	cout << mari.lekerNev() << endl;
	return 0;
}
</code>


Az egységbezárás így még magasabb szinten valósul meg.


===== A struktúra és az osztály =====

A struktúra és az osztály között a különbség, hogy az osztályban minden tag
alapértelmezetten private elérésű, míg a struktúrában public. 

<code c++ program01.cxx>
#include <iostream>

using namespace std;

class Dolgozo {
	string nev;
  public:
	void beallitNev(string ujNev) {
		nev = ujNev;
	}
	string lekerNev() {
		return nev;
	}
};

int main(int argc, char **argv) {
	Dolgozo mari;
	mari.beallitNev("Nagy Mária");
	cout << mari.lekerNev() << endl;
	return 0;
}
</code>



===== Függvény megvalósítása osztályban =====

A tagfüggvényeket ugyan megvalósíthatjuk osztályon belül, mint az alábbi példában látjuk, azonban az osztályokat külön fejlécfájlba szokás rakni. A fejlécfájlokban pedig nem szokás függvényeket megvalósítani.

<code c++ program01.cxx>
#include <iostream>

using namespace std;

class Dolgozo {
	string nev;
  public:
	void allitNev(string nev) {
		this->nev = nev;
	}
};

int main(int argc, char **argv) {
	Dolgozo mari;
	mari.allitNev("Mária");
 
	return 0;
}
</code>


===== Az osztály külön állományban =====

<code c++ dolgozo.h>
 #include <iostream>
using namespace std;
 
class Dolgozo {
	string nev;
	int kor;
	double fizetes;
  public:
	void beallitNev(string ujNev);
	string lekerNev();
	Dolgozo();	
	~Dolgozo();	
};
</code>

<code c++ dolgozo.cxx>
#include "dolgozo.h"
using namespace std;
Dolgozo::Dolgozo () {
	nev = "Névtelen";
	kor = 0;
}
 
Dolgozo::~Dolgozo () {
	//Destruktor
}
 
void Dolgozo::beallitNev(string ujNev) {
	nev = ujNev;
}
 
string Dolgozo::lekerNev() {
	return nev;
}
</code>

<code c++ main.cxx>
#include <iostream>
#include "dolgozo.h"
using namespace std;

int main(int argc, char **argv) {
	Dolgozo joska;
	std::cout << joska.lekerNev() << std::endl;
	joska.beallitNev("Nagy Lajos");
	std::cout << joska.lekerNev() << std::endl;
	return 0;
}
</code>

<code make Makefile>
TARGET = main
CXX = g++
RM = rm
CPPFLAGS = -Wall -g
LDFLAGS =
SRCS = main.cxx dolgozo.cxx
HEADS = dolgozo.h
OBJS = main.o dolgozo.o
 
${TARGET}: ${OBJS}
	${CXX} ${LDFLAGS} -o ${TARGET} ${OBJS}
 
${OBJS}.o:${SRCS} ${HEADS}
	${CXX} ${CPPFLAGS} -c ${SRCS}
 
clean:
	${RM} ${OBJS} ${TARGET}
</code>

===== Osztály létrehozása =====

<code c++ program01.cpp>
#include <iostream>

using namespace std;

class Dolgozo {
	string nev;
	int kor;
	double fizetes;
  public:
	void beallitNev(string ujNev);
	string lekerNev();
	Dolgozo();	
	~Dolgozo();	
};

Dolgozo::Dolgozo () {
	nev = "Névtelen";
	kor = 0;
}

Dolgozo::~Dolgozo () {
	//Destruktor
}

void Dolgozo::beallitNev(string ujNev) {
	nev = ujNev;
}

string Dolgozo::lekerNev() {
	return nev;
}

int main(int argc, char **argv) {
	Dolgozo joska;
	std::cout << joska.lekerNev() << std::endl;
	joska.beallitNev("Nagy Lajos");
	std::cout << joska.lekerNev() << std::endl;
	return 0;
}

</code>

===== Többalakú konstruktor =====
<code c++ program01.cxx>

#include <iostream>
using namespace std;
class Dolgozo {
	string nev;
  public:
	Dolgozo() {
		nev = "Névtelen";
	}
	Dolgozo(string ujNev) {
		nev = ujNev;
	}
	string lekerNev() {
		return nev;
	}
};


int main(int argc, char **argv)
{
	Dolgozo mari("Nagy Mária");;
	cout << mari.lekerNev() << endl;
	
	return 0;
}

</code>

===== Destruktor =====

A destruktorban törölhetjük a dinamikusan létrehozott (mutató) tagokat:

<code c++ program01.cxx>
#include <iostream>
using namespace std;
class Dolgozo {
  public:
	double *fizetes;

	Dolgozo() {
		fizetes = new double;
	}
	~Dolgozo() {
		delete fizetes;
		cout << "A destruktor lefutott" << endl;
	}
};

int main(int argc, char **argv) {
	Dolgozo janos;
	*janos.fizetes = 820000;
	cout << *janos.fizetes << endl;
	return 0;
}
</code>

===== Öröklés =====

<code c++>
class Szemely {
  protected:
	string nev;
	string szuletes;	
};

class Dolgozo  : Szemely {	
	double fizetes;
  public:
	void beallitNev(string ujNev);
	string lekerNev();
	Dolgozo();	
	~Dolgozo();	
};
</code>

===== Többszörös öröklés =====

<code c++ program01.cxx>

#include <iostream>

class A {
	int a;
};

class B {
	int b;
};

class C : public A, public B {
	
};

int main(int argc, char **argv) {
	C o;
	o.a = 3;
	o.b = 5;
	std::cout << o.a << std::endl;
	std::cout << o.b << std::endl;	
	return 0;
}
</code>
===== Dinamikus adattagokat tartalmazó osztály =====

<code c++ program01.cxx>

#include <iostream>
using namespace std;
class Dolgozo {
	string nev;
  public:
	Dolgozo() {
		nev = "Névtelen";
	}
	Dolgozo(string ujNev) {
		nev = ujNev;
	}
	string lekerNev() {
		return nev;
	}
};

int main(int argc, char **argv)
{	
	Dolgozo* peti = new Dolgozo("Kék Péter");
	cout << peti->lekerNev() << endl;
	return 0;
}
</code>