Skip to content

Prog2 / labor_peldak / lab_09

Go to a project
Commit 580c0a36 by Szeberényi Imre
Options

Makefile

parent 31ec2675
Showing with 4 additions and 367 deletions
genArray3/Makefile
......@@ -2,15 +2,15 @@
# Solaris (ural2) es Linux ala.
# forditando obj. fajlok
objs = gen_array_iter2_test.o
objs = gen_array_iter3_test.o
# headerek, melyektol az egyszeruseg kedveert minden fugg
heads = gen_array_iter2.hpp
heads = gen_array_iter3.hpp sablonok.hpp gtest_lite.h
prog = gen_array_iter2_test # a program neve
prog = gen_array_iter3_test # a program neve
CXX = g++ # a C++ fordito neve
CXXFLAGS = -pedantic -Wall # C++ kapcsolok: legyen bobeszedu,
CXXFLAGS = -pedantic -Wall -std=c++11 # C++ kapcsolok: legyen bobeszedu,
CXXFLAGS += -g # ... es forduljon debug info is
# alapertelmezett cel: tesztprogram linkelese
......
genArray3/gen_array_iter3.cbp deleted 100644 → 0
<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="6" />
<Project>
<Option title="gen_array_iter3" />
<Option pch_mode="2" />
<Option compiler="gcc" />
<Build>
<Target title="Debug">
<Option output="bin/Debug/genarray3" prefix_auto="1" extension_auto="1" />
<Option object_output="obj/Debug/" />
<Option type="1" />
<Option compiler="gcc" />
<Compiler>
<Add option="-g" />
</Compiler>
</Target>
<Target title="Release">
<Option output="bin/Release/genarray3" prefix_auto="1" extension_auto="1" />
<Option object_output="obj/Release/" />
<Option type="1" />
<Option compiler="gcc" />
<Compiler>
<Add option="-O2" />
</Compiler>
<Linker>
<Add option="-s" />
</Linker>
</Target>
</Build>
<Compiler>
<Add option="-pedantic" />
<Add option="-std=c++11" />
<Add option="-Wall" />
</Compiler>
<Unit filename="gen_array_iter3.hpp" />
<Unit filename="gen_array_iter3_test.cpp" />
<Unit filename="gtest_lite.h" />
<Unit filename="integer.h" />
<Unit filename="sablonok.hpp" />
<Extensions>
<code_completion />
<debugger />
<envvars />
<DoxyBlocks>
<comment_style block="0" line="0" />
<doxyfile_project />
<doxyfile_build />
<doxyfile_warnings />
<doxyfile_output />
<doxyfile_dot />
<general />
</DoxyBlocks>
</Extensions>
</Project>
</CodeBlocks_project_file>
genArray3/gen_array_iter3.hpp deleted 100644 → 0
/**
* \file gen_array_iter3.hpp
*
* Generikus tömb iterátorral v3.
* Előadáson bemutatott kód módosított változata.
* Interfész jobban hasonlít az std::vector-ra.
* Van konstans iterarora is.
*/
#ifndef GEN_ARRAY_ITER3
#define GEN_ARRAY_ITER3
#include <stdexcept>
/**
* Fix méretű generikus tömb.
* @param T - tárolt adattípus
* @param maxsiz - maximális méret
*/
template<class T, size_t maxsiz = 6>
class Array {
size_t siz; // adatok tényleges mennyisége
T t[maxsiz]; // elemek (adatok) tömbje
public:
/// minden implicit tagfüggvény jó, nem kell átdefiniálni
class iterator; // elődeklaráció
class const_iterator; // konstans objektumra hivatkozó iterator elődeklarációja
/// default és konstans értékkel feltöltő konstruktor
/// @param n - méret
/// @param value - érték, amivel feltölt
explicit Array(size_t n = 0, const T& value = T()) : siz(0) {
while (siz < n && siz < maxsiz)
t[siz++] = value;
}
/// konstruktor sorozatból
/// @param first - sorozat elejére mutat
/// @param last - utolsó elem után
template <class InputIterator>
Array(InputIterator first, InputIterator last) : siz(0) {
while (first != last && siz < maxsiz) // átmásolunk, amíg lehet
t[siz++] = *first++;
}
/// létrehoz egy iterátort és az elejére állítja
/// @return - iterátor az adatsorozat elejére
iterator begin() {
return iterator(*this); // ld. iterátor konstruktor
}
/// létrehoz egy iterátort és az utolsó elem után állítja
/// @return - iterátor az adatsorozat végére
iterator end() {
return iterator(*this, siz);// ld. iterátor konstruktor
}
/// létrehoz egy konstans objektumra alkalmazható iterátort és az elejére állítja
/// @return - iterátor az adatsorozat elejére
const_iterator begin() const {
return const_iterator(*this); // ld. iterátor konstruktor
}
/// létrehoz egy iterátort és az utolsó elem után állítja
/// @return - iterátor az adatsorozat végére
const_iterator end() const {
return const_iterator(*this, siz);// ld. iterátor konstruktor
}
/// Elemek tényleges száma
/// @return - ténylegesen tárolt elemek száma
size_t size() const { return siz; }
/// Tömb allokált (maximális) kapacitása
/// @return - tömb allokált (maximális) kapacitása
size_t capacity() const { return maxsiz; }
/// Tömb allokált maximális kapacitása
/// Mivel a tömb fix méretű így a max_size és a capacity megegyezik.
/// @return - tömb maximális kapacitása
size_t max_size() const { return maxsiz; }
/// at
/// @param i - index
/// @return - i. elem referenciája, vagy out_of_range hiba
T& at(size_t i) {
if (i >= maxsiz) throw std::out_of_range("Array.at(): hibas index");
if (i >= siz) siz = i+1; // növeljük a tényleges méretet
return t[i];
}
/// at konstans változata.
/// konstans esetén nem változhat a méret
/// @param i - index
/// @return i. elem referenciája, vagy out_of_range hiba
const T& at(size_t i) const {
if (i >= siz) throw std::out_of_range("Array.at(): hibas index");
return t[i];
}
/// iterator osztály
/// input/output (STL::ForwardIterator) iterátorként használható
class iterator {
Array *p; // tároljuk, hogy melyik az objektumhoz tartozik az iterátor
size_t idx; // tároljuk az aktuális index értéket
public:
/// default konstruktor
iterator() :p(0), idx(0) {}
/// konstruktor, egy konkrét objektum ix-edik elemére mutat
/// @param a - a konkrét objektum
/// @param ix - ide állítja az indexet
iterator(Array& a, size_t ix = 0)
: p(&a), // az objektumra mutat
idx(ix) {} // erre az elemre áll
/// pre-inkremens
/// csak hatékonyság miatt ref. visszatérésű,
/// értelmetlen lenne balértékként használni
iterator& operator++() {
if (idx != p->siz) ++idx; // nem engedjük túllépni
return *this;
}
/// post-inkremens
iterator operator++(int); // Ezt el kell készítenie
/// egyenlőtlenség vizsgálat
/// @param i - jobboldali operandus
bool operator!=(const iterator &i) {
return(idx != i.idx);
}
/// egyenlőség vizsgálat
/// @param i - jobboldali operandus
bool operator==(const iterator &i) {
return !operator!=(i);
}
/// indirekció
T& operator*() {
if (idx != p->siz) return p->t[idx];
else throw std::runtime_error("Hibas indirekcio");
}
/// Szelekció pointerrel (nyil). Címet kell, hogy adjon.
T* operator->() {
return &operator*();
}
}; // iterator osztály vége
/// const_iterator osztály
/// Visszavezetjük az iterator osztályra.
class const_iterator : public iterator {
public:
/// default konstruktor
const_iterator() {}
/// konstruktor, egy konkrét objektum ix-edik elemére mutat
/// @param a - a konkrét objektum
/// @param ix - ide állítja az indexet
const_iterator(const Array& a, size_t ix = 0)
: iterator(const_cast<Array&>(a), ix) {} /// Kis trükközés a kasztolással...
const T& operator*() const {
return iterator::operator*();
}
/// Szelekció pointerrel (nyil). Címet kell, hogy adjon.
const T* operator->() const {
return &operator*();
}
};
/// Virtuális destruktor.
/// Most nem használjuk, de egy generikus osztály későbbi
/// felhasználási módja kevésbé látszik.
virtual ~Array() {}
}; // generikus tömb vége
#endif
genArray3/gen_array_iter3_test.cpp deleted 100644 → 0
/**
* Egyszerű program az iterátoros generikus tömb kipróbálásához.
*/
#include <iostream>
#include <stdexcept>
#include <sstream>
#include "integer.h"
#include "sablonok.hpp"
#include "gen_array_iter3.hpp"
#include "gtest_lite.h"
/// Ellenőrizzük, hogy a sablonok.hpp-ben definiálta-e az ELKESZULT makrót
#ifndef ELKESZULT
#define ELKESZULT 0 /// ha mégse definiálta
#endif
#if ELKESZULT < 0 /// ha hibásan definiálta
#undef ELKESZULT
#define ELKESZULT 0
#endif
/// ------- Ellenőrző rész vége ----------
using std::cout;
using std::endl;
/// Összegző funktor (6. részfeladathoz)
/// ELKESZULT == 15-höz
struct Sum {
int sum;
Sum(int s=0) :sum(s) {}
void operator()(int i) { sum += i;}
};
/// Egyszerű C stílusú tömbök, amiből majd az adatokat vesszük
int itomb[] = { -5, 11, 13, -2, -1, 0, 1, -82, 3, 4 };
double dtomb[] = { .0, .1, .2, .3, 4.4, -12.4, 8.7 };
const char* txtomb[] = { "C#" , "C", "C++", "Java", "C++11" };
int main() {
try {
/// az int tömbből létrehozuk az intarr0-át
Array<int> intarr0(itomb, itomb+10);
/// a double tömbből létrehozzuk a dblarr0-át
Array<double, 20> dblarr0(dtomb, dtomb+7);
/// const char* tömbből pedig létrehozzuk a txarray-t
Array<const char*> txarray(txtomb, txtomb+5);
#if ELKESZULT <= 11 // csak az elején, hogy máskor ne zavarjon a kivétel
/// szándékosan rosszul indexelünk
cout << intarr0.at(112);
#endif // ELKESZULT <= 11
#if ELKESZULT >= 12
/// Kiírjuk a tömböket.
PrintArray("intarr0", intarr0);
PrintArray("dblarr0", dblarr0);
PrintArray("txarray", txarray);
/// Adatokat is kiírja?
TEST(PrintArray, adat) {
char cpp[] = "C++";
Array<char, 10> carr(cpp, cpp+3); /// létrehozzuk
std::stringstream out; /// ide ír, az out adatfolyamba
PrintArray("cpp", carr, out);
// out-nak a sztring "arcát" összehasonlítjuk az elvárt sztringgel
EXPECT_EQ(std::string("cpp size=3 capacity=10\n\t data=C,+,+\n"), out.str()) << "== Nem jo a kiiras formatuma!\n";
END }
#endif // ELKESZULT >= 12
#if ELKESZULT >= 13
/// Ellenőrizzük az Array post-inkremens iterátorát:
Array<int>::iterator i1, i2;
i1 = i2 = intarr0.begin();
if (i1 != i2++) { cout << "** HIBAS az iterator post-inkremens operatora **\n"; }
#endif // ELKESZULT >= 13
#if ELKESZULT >=14
/// intarr0-ból létrehozzuk az intarr1-et
Array<int, 100> intarr1(intarr0.begin(), intarr0.end());
/// Kiírjuk az elemeket.
PrintArray("\bintarr1", intarr1);
#endif // ELKESZULT >= 14
#if ELKESZULT >= 15
// Számlálja össze az intarr1-ben az 5-nél nagyobb elemeket!
// Használja a korábban elkészített szamol_ha sablont!
#error "egeszitse ki a kodot"
int db =
cout << "\nintarr1-ben 5-nel nagyobb: ";
cout << db << " db" << endl;
#endif // ELKESZULT >= 15
#if ELKESZULT >= 16
Sum s = forEach(intarr1.begin(), intarr1.end(), Sum());
cout << "\nintarr0 osszegzes forEach segitsegevel: " << s.sum << endl;
#endif // ELKESZULT >= 16
#if ELKESZULT >= 17
cout << "intarr0 kiiras forEach segtisegevel: ";
ostreamFunctor<int> out(cout, ",");
forEach(intarr1.begin(), intarr1.end(), out);
cout << endl;
#endif // ELKESZULT >= 17
#if ELKESZULT >= 18
/// Itt valamilyen memóriaszemét lesz
cout << "\nMemoriaszemet: " << intarr1.at(12) << endl;
/// Itt meg nincs memóriaszemét. Miért?
Array<Integer,100> Ia;
cout << "Ez meg nulla: "<< Ia.at(12) << endl;
#endif // ELKESZULT >= 18
} catch (std::exception& e) { // az out_of_range, és a runtime_error is az exception
// osztályból származik. Így azok kompatibilisek
// az alaposztállyal
cout << e.what() << endl;
}
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or sign in to comment