typo

komplex_oo1/komplex_oo1.cpp

 /**
- * \mainpage 10 komplex szm abszoltrtke
+ * \mainpage 10 komplex szám abszolút értéke
  *
  * \section feladat Feladat
- * Olvassunk be pontosan 10 komplex szmot, majd
- * rjuk ki a szmokat s abszolt rtkket fordtott sorrendben!
+ * Olvassunk be pontosan 10 komplex számot, majd
+ * írjuk ki a számokat és abszolút értéküket fordított sorrendben!
  *
- * \section megv Megvalsts
- * Megvalsts: objektum-orientlt dekompozcival
- * operetor overload hasznlata nlkl.
+ * \section megv Megvalósítás
+ * Megvalósítás: objektum-orientált dekompozícióval
+ * operetor overload használata nélkül.
  *
- * \section korl Korltozs, hinyossgok
- * Nincs indexhatr ellenrzs.
- * Csak a hasznlt metdusokat valstottuk meg.
+ * \section korl Korlátozás, hiányosságok
+ * Nincs indexhatár ellenőrzés.
+ * Csak a használt metódusokat valósítottuk meg.
  *
  */
 
@@ -23,50 +23,50 @@ using std::cout;
 using std::endl;
 
 /**
- * Komplex osztly
- * Komplex viselkedst megvalst osztly.
- * Most csak a feladat megvalstshoz szksges mveleteket definiljuk
+ * Komplex osztály
+ * Komplex viselkedést megvalósító osztály.
+ * Most csak a feladat megvalósításához szükséges műveleteket definiáljuk
  */
 class Komplex {
-	double re;		// vals rsz
-	double im;		// kpzetes rsz
+	double re;		// valós rész
+	double im;		// képzetes rész
 public:
     void beolvas()   { cin >> re >> im; }               ///< Komplex beolvas
-    void kiir()      { cout << re << ' ' << im; }       ///< Komplex kirs
-    double abs()     { return sqrt(re*re + im*im); }    ///< abszolt rtk
+    void kiir()      { cout << re << ' ' << im; }       ///< Komplex kiírás
+    double abs()     { return sqrt(re*re + im*im); }    ///< abszolút érték
 };
 
 /**
- * KomplexTar osztly
- * Trol ami max 10 komplex szmot tud trolni
- * Az egyszer?sg kedvrt nincs indexhatr ellen?rzs !
+ * KomplexTar osztály
+ * Tároló ami max 10 komplex számot tud tárolni
+ * Az egyszer?ség kedvéért nincs indexhatár ellen?rzés !
  */
 class KomplexTar {
-    Komplex t[10];      // bels? objektumtmbt tartalmaz a trolshoz
+    Komplex t[10];      // bels? objektumtömböt tartalmaz a tároláshoz
 public:
-    void tarol(const int i, const Komplex& k) { t[i] = k; } ///< Betesz a trba
-    Komplex elovesz(const int i) { return t[i]; }           ///< Kivesz a trbl
+    void tarol(const int i, const Komplex& k) { t[i] = k; } ///< Betesz a tárba
+    Komplex elovesz(const int i) { return t[i]; }           ///< Kivesz a tárból
 };
 
 
 /**
- * F?program.
+ * Főprogram.
  */
 int main()
 {
-    KomplexTar t;       // trol ltrehozsa
+    KomplexTar t;       // tároló létrehozása
     int i;              // nem a for-ban van, hogy visual C++ 6.0 -ban is jo legyen
 
     for (i = 0; i < 10; i++) {
-        Komplex k;      // komplex ltrehozsa
-        k.beolvas();    // beolvas a megfelel? formtumban
-        t.tarol(i, k);  // trol
+        Komplex k;      // komplex létrehozása
+        k.beolvas();    // beolvas a megfelel? formátumban
+        t.tarol(i, k);  // tárol
     }
 
     for (i = 9; i >= 0; i--) {
-        Komplex k = t.elovesz(i); // definci s inic.
-        k.kiir();       // kiir a megfelel? formtumban
-        cout << ' ' << k.abs() << endl; // abszolt rtket is
+        Komplex k = t.elovesz(i); // definíció és inic.
+        k.kiir();       // kiir a megfelel? formátumban
+        cout << ' ' << k.abs() << endl; // abszolút értéket is
     }
     return 0;
 }

komplex_oo2/komplex_oo2.cpp

 /**
- * \mainpage 10 komplex szám abszolútértéke
+ * \mainpage 10 komplex szám abszolút értéke
  *
  * \section feladat Feladat
  * Olvassunk be max 10 komplex számot, majd
- * írjuk ki a számokat és abszolútértéküket fordított sorrendben!
+ * írjuk ki a számokat és abszolút értéküket fordított sorrendben!
  *
  * \section megv Megvalósítás
  * Megvalósítás objektum-orientált dekompozícióval és
  * operátor overload használatával.
  *
  * \section korl Korlátozás, hiányosságok, kiegészítés
- * Nincs indexhatárellenőrzés.
- * Összedás művelet tesztjei és a cast hatásának demonstrálása
+ * Nincs indexhatár ellenőrzés.
+ * Összeadás művelet tesztjei és a cast hatásának demonstrálása
  *
  * \section fordítási opciók
  * Ha az OP_K_PLUS_D azonosító nincs definiálva, akkor
@@ -56,7 +56,7 @@ public:
 	double getRe() const    { return re; }
 	double getIm() const    { return im; }
 	// cast operator
-    operator double() const { return sqrt(re*re + im*im); }   ///< abszolútérték
+    operator double() const { return sqrt(re*re + im*im); }   ///< abszolút érték
     // összeadások
     Komplex operator+(const Komplex& k) const { 	// komplex + komplex
         Komplex sum(k.re + re, k.im + im);
@@ -98,7 +98,7 @@ ostream& operator<<(ostream& s, const Komplex k) {
 /**
  * KomplexTar osztály.
  * Tároló ami max 10 komplex számot tud tárolni
- * Az egyszerűség kedvéért nincs indexhatár ellenűrzés!
+ * Az egyszerűség kedvéért nincs indexhatár ellenőrzés!
  */
 class KomplexTar {
     Komplex t[10];      // belső objektumtömböt tartalmaz a tároláshoz