Untitled

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>

using namespace std;
#define ZadanieP

/* Zmieniając ostatnią literę w poniższej instrukcji na D (dodatkowe), lub P (podstawowe)
*  wybierasz aktywne zadanie.
*
*  UWAGA: jeśli rozwiązanie zadań wymaga podziału programu na pliki to dodaj je wszystkie do
*  projektu, ale przy każdym zadaniu "includuj" tylko te, które jego dotyczą.
*  Poniższe bloki dotyczą zadań z zajeć.
*/
 

#ifdef ZadanieD

#include <cmath>
#include <cstring>
#include <iostream>

class Koder
{
protected:
	char m_klucz[16] = {};
	static int licznik;
	int index;
	static int rozmiarTab;
	static Koder** koderTab;

	void alokacja() {
		int tempRozmiar;
		if (rozmiarTab > 0)
			tempRozmiar = rozmiarTab;
		else
			tempRozmiar = 1;
		rozmiarTab *= 10;
		if (koderTab != nullptr) {
			Koder** temp = koderTab;
			koderTab = new Koder * [rozmiarTab];
			for (int i = 0; i < tempRozmiar; i++)
				koderTab[i] = temp[i];
			delete[] temp;
		}
		else
			koderTab = new Koder * [rozmiarTab];
	}

	void zwolnienie() {
			delete[] koderTab;
			koderTab = nullptr;
	}
	void kopiowanie(const Koder& koder) {
		if (getLicznik() >= getRozmiarTab())
			alokacja();
		index = licznik;
		koderTab[index] = this;
	}
public:
	Koder(const char* i_klucz) { 
		if (getLicznik() >= getRozmiarTab())
			alokacja();
		index = getLicznik();
		koderTab[index] = this;
		licznik++;
		setKlucz(i_klucz); 
	}
	~Koder() { 
		licznik--;
		koderTab[getLicznik()]->index = index;
		swap(koderTab[index], koderTab[getLicznik()]);
		koderTab[getLicznik()] = nullptr;
		if (getLicznik() < 0)
			zwolnienie();
	}
	//Konstruktor kopiujacy
	Koder(const Koder& koder) {
		kopiowanie(koder);
		licznik++;	
		setKlucz(koder.m_klucz);
	}
	//Operator kopiujacy
	Koder& operator=(const Koder& koder) {
		kopiowanie(koder);
		setKlucz(koder.m_klucz);
		return *this;
	}
	//Konstruktor przenoszacy
	Koder(Koder&& koder) noexcept {
		if (getLicznik() >= getRozmiarTab())
			alokacja();
		strcpy(m_klucz, koder.m_klucz);
		koderTab[koder.licznik] = this;
		licznik++;
	}
	//Operator przenoszacy
	Koder& operator=(Koder&& koder) noexcept {
		strcpy(m_klucz, koder.m_klucz);
		return *this;
	}
	int ileDuplikatow() {
		int ile = 0;
		for (int i = 0; i < licznik; i++) {
			if(this != koderTab[i])
				if(!strcmp(this->m_klucz,koderTab[i]->m_klucz))
					ile++;
		}
		return ile;
	}
	int getLicznik() { return licznik; }
	int getRozmiarTab() { return rozmiarTab; }


	void setKlucz(const char* i_klucz)
	{
		if (i_klucz != nullptr)
			strncpy(m_klucz, i_klucz, 16);
	}
	void szyfruj(char* i_info, size_t i_liczZnak) const
	{
		if (i_info != nullptr && i_liczZnak > 0)
			for (size_t i = 0; i < i_liczZnak; i++)
				i_info[i] ^= m_klucz[i % 16];
	}
	void deszyfruj(char* i_info, size_t i_liczZnak) const
	{
		szyfruj(i_info, i_liczZnak);
	}
	int getIndex() { return index; }
};

int Koder::licznik = 0;
int Koder::rozmiarTab = 10;
Koder** Koder::koderTab = new Koder*[rozmiarTab]; 

void testKopiowanie() {
	cout << "Test konstruktora: ";
	Koder k1("222");
	Koder k2(k1);
	if (k1.getLicznik() == 2)
		cout << "OK\n";
	else
		cout << "FALSE\n";
	cout << "Test operatora: ";
	Koder k3("111");
	Koder k4 = k3;
	if (k3.getLicznik() == 4)
		cout << "OK\n";
	else
		cout << "FALSE\n";
}

void testUsuwanie() {
	Koder* k1 = new Koder("111");
	Koder* k2 = new Koder("111");
	Koder* k3 = new Koder(*k1);
	cout << "Utworzenie: ";
	if (k1->getLicznik() == 3)
		cout << "OK\n";
	else
		cout << "FALSE\n";
	cout << "Usuwanie: ";
	delete k1;
	delete k2;
	if (k3->getLicznik() == 1) 
		cout << "OK\n";	
	else
		cout << "FALSE\n";
	delete k3;
}

Koder tempInstancja() {
	Koder wynik("333");
	return wynik;
}

void testPrzenoszenie() {
	Koder instA = tempInstancja();
	cout << "Test konstruktora przenoszacego: ";
	if (instA.getLicznik() == 1)
		cout << "OK\n";
	else
		cout << "FALSE\n";
	instA = Koder("123");
	cout << "Test operatora przenoszacego: ";
	if (instA.getLicznik() == 1)
		cout << "OK\n";
	else 
		cout << "FALSE\n";
}

void main(void)
{
	testPrzenoszenie();
	testKopiowanie();
	testUsuwanie();
}

#endif

#ifdef ZadanieP
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

void testKopia();
void testModyfikacji();
void testPrzeniesienie();

class Koder
{
	friend void testKopia();
	friend void testModyfikacji();
	friend void testPrzeniesienie();
	int rozmiar = 0;
	char* m_klucz = nullptr;
	void zwolnij() {
		if (m_klucz != nullptr) {
			delete[] m_klucz;
			m_klucz = nullptr;
		}
	}
public:
	Koder(const char* i_klucz) { 
		if (i_klucz != nullptr) {
			rozmiar = strlen(i_klucz) + 1;
			if (m_klucz == nullptr) {
				m_klucz = new char[rozmiar];
				if (rozmiar > 0)
					strcpy(m_klucz, i_klucz);
				else {
					m_klucz = new char[16];
					srand(time(NULL));
					for (int i = 0; i < 16; i++)
						m_klucz[i] = rand() % 127 + 31;
				}
			}
		}
	}

	~Koder() {
		zwolnij();
	}

	Koder(const Koder& org)
		:rozmiar(org.rozmiar)
	{
		if (org.m_klucz != nullptr) {
			m_klucz = new char[rozmiar];
			strcpy(m_klucz, org.m_klucz);
		}
	}

	Koder& operator=(const Koder& org) {
		strcpy(m_klucz, org.m_klucz);
		rozmiar = org.rozmiar;
		return *this;
	}

	Koder(Koder&& org) noexcept 
		:rozmiar(org.rozmiar)
	{
		if (org.m_klucz != nullptr) {
			m_klucz = new char[rozmiar];
			strcpy(m_klucz, org.m_klucz);
			org.m_klucz = nullptr;
		}
	}

	Koder& operator=(Koder&& org) noexcept {
		strcpy(m_klucz, org.m_klucz);
		rozmiar = org.rozmiar;
		org.m_klucz = nullptr;
		return *this;
	}

	void setKlucz(const char* i_klucz)
	{
		if (i_klucz != nullptr) {
			int charSize = strlen(i_klucz) + 1;
			if (charSize > 0) {
				if (rozmiar == charSize)
					strncpy(m_klucz, i_klucz, rozmiar);
				else {
					zwolnij();
					rozmiar = strlen(i_klucz) + 1;
					if (m_klucz == nullptr) {
						m_klucz = new char[rozmiar];
						strcpy(m_klucz, i_klucz);
					}
				}
			}
			}
		}
	
	void szyfruj(char* i_info, size_t i_liczZnak) const
	{
		if (i_info != nullptr && i_liczZnak > 0)
			for (size_t i = 0; i < i_liczZnak; i++)
				i_info[i] ^= m_klucz[i % 16];
	}

	void deszyfruj(char* i_info, size_t i_liczZnak) const
	{
		szyfruj(i_info, i_liczZnak);
	}
};

//Zadanie ambitne testy konstruktorow
void testKopia() {
	Koder k1("123");
	Koder k2(k1);
	if (strcmp(k1.m_klucz, k2.m_klucz)) {
		cout << "Konstruktor argumentowy: FAIL" << endl;
	}
	else
		cout << "Konstruktor kopiujacy: OK" << endl;
}

void testModyfikacji() {
	Koder k1("123");
	cout << "Konstruktor argumentowy: ";
	if (!strcmp(k1.m_klucz, "123")) {
		cout << "OK" << endl;
	}
	else
		cout << "FAIL" << endl;
	Koder k2(k1);
	k2.setKlucz("5555");
	if (strcmp(k1.m_klucz, k2.m_klucz)) {
		cout << "Konstruktor argumentowy 1/2: OK" << endl;
	}
	else
		cout << "Konstruktor kopiujacy 1/2: FAIL" << endl;
	if (!strcmp(k1.m_klucz, "123")) {
		cout << "Konstruktor argumentowy 2/2: OK" << endl;
	}
	else
		cout << "Konstruktor kopiujacy 2/2: FAIL" << endl;
}

Koder fTworzaca() {
	Koder k1("000");
	return k1;
}

void testPrzeniesienie() {
	Koder instA = fTworzaca();
	cout << "Test konstruktora przenoszacego: ";
	if (!strcmp(instA.m_klucz, "000"))
		cout << "OK\n";
	else
		cout << "FALSE\n";
}

void main(void)
{
	Koder maszyna("12");
	Koder k1 = maszyna;
	testKopia();
	testModyfikacji();
	testPrzeniesienie();
}

#endif

#ifdef ZadanieA

// TU UMIEŚĆ KOD ROZWIAZANIA ZADANIA AMBITNEGO

#endif