Differences

This shows you the differences between two versions of the page.

Link to this comparison view

poo-is:laboratoare:03 [2020/09/09 12:12]
alexandru.ionita99 [2. Structura de fișiere a unei aplicații]
poo-is:laboratoare:03 [2020/10/22 12:30] (current)
andreea.udrea
Line 1: Line 1:
-===== Laboratorul 03: Definirea și utilizarea claselor. Funcții ​constructor ​=====+===== Laboratorul 03: Clase. Funcții ​Constructor ​=====
  
-**__Introducere__\\+In cadrul Laboratorului 3 vom explica si exemplifica cateva notiuni teoretice ce stau la baza Programarii Orientate pe Obiecte, precum clasele, functiile membre, constructorii si destructorii. De asemenea, vom prezenta o aplicatie C++, construita prin crearea de fisiere distincte, tocmai pentru a ne obisnui cu acest mod de dezvoltare a aplicatiilor. ​
  
-__Resurse__**+Pentru a aprofunda aceste concepte, recomandam urmatoarele capitole din [[https://​discourse-production.oss-cn-shanghai.aliyuncs.com/​original/​3X/​2/​3/​2380479dcb8e375425884a10da232730bbc7f88d.pdf|Absolute C++]] 
 +  ​Capitolul 6 (Chapter 6. pag 239-274): Structures and Classes 
 +  ​Capitolul 7 (Chapter 7. pag 275-320): Constructors and Other Tools
  
 ==== 1. Introducere în programarea obiectuală ==== ==== 1. Introducere în programarea obiectuală ====
Line 37: Line 39:
 { {
   private: //implicit private, daca nu specificam ​   private: //implicit private, daca nu specificam ​
-   ​string producator;+   ​string producator; ​// pentru tipul string folositi documentatia din laboratorul 10
    ​string model;    ​string model;
    ​string culoare;    ​string culoare;
Line 146: Line 148:
 } }
  
-Dreptunghi::​Dreptunghi(const Dreptunghi&​ d) +Dreptunghi::​Dreptunghi(const Dreptunghi&​ d) //As putea sa nu implementez constr de copiere si sa il folosesc pe cel generat automat. 
-{+                                          //deoarece nu am atribute pointer
     this->​lungime = d.lungime;     this->​lungime = d.lungime;
     this->​latime = d.latime;     this->​latime = d.latime;
Line 154: Line 156:
 Dreptunghi::​~Dreptunghi() Dreptunghi::​~Dreptunghi()
 { {
-    //Nu trebuie eliberat manual spatiul de memorie. ​Eventual, putem seta parametrii egali cu 0: +    //Nu trebuie eliberat manual spatiul de memorie. ​As putea sa nu implementez destructorul si sa il folosesc pe cel generat automat. 
-    ​this->​lungime = 0; + 
-    ​this->​latime = 0;+   ​
 } }
  
Line 175: Line 177:
 <note warning>​Impartirea in fisiere header si sursa nu este obligatorie,​ dar este indicata pentru usurinta in citirea codului. </​note>​ <note warning>​Impartirea in fisiere header si sursa nu este obligatorie,​ dar este indicata pentru usurinta in citirea codului. </​note>​
  
-In continuare, vom prezenta un exemplu de aplicatie ce respecta structura de fisiere mentionata anterior. ​Aplicatia ​poate fi **rulata si descarcata** [[https://​repl.it/​@alexionita99/​lab3stack|aici]]:​+In continuare, vom prezenta un exemplu de aplicatie ce respecta structura de fisiere mentionata anterior. ​Fisierele pot fi descarcate printr-un click pe numele lor, iar intreaga aplicatie ​poate fi **rulata si descarcata** [[https://​repl.it/​@alexionita99/​lab3stack|aici]]:​
  
 Fisierul **stack.h** contine definitia clasei: Fisierul **stack.h** contine definitia clasei:
-<code cpp> +<code cpp stack.h
-class stack { +class stack  
-int *buf; +
-int sp; // Acesti membri sunt impliciti private. +    int *buf; 
-int nrmax; // Ei pot fi accesati doar prin functii (metode) +    int sp; // Acesti membri sunt impliciti private. 
-char nume[10]; // ale clasei +    int nrmax; // Ei pot fi accesati doar prin functii (metode) 
 +    char nume[10]; // ale clasei
  
 public: public:
Line 192: Line 194:
 // Functia constructor este apelata la crearea obiectelor (statica, auto sau dinamica). // Functia constructor este apelata la crearea obiectelor (statica, auto sau dinamica).
 // //
-stack (const char *); +    ​stack (const char *); 
-stack (int, const char *); // Alt constructor care va fi definit in exterior+    stack (int, const char *); // Alt constructor care va fi definit in exterior
  
-~stack(); // Destructor: functie care va fi apelata la incetarea+    ​~stack(); // Destructor: functie care va fi apelata la incetarea
 // duratei de viata a obiectului // duratei de viata a obiectului
  
-int is_empty() { return sp == -1; }     // Functii implementate in  +    ​int is_empty() { return sp == -1; }     // Functii implementate in  
-int is_full() { return sp == nrmax-1; } // definitia clasei +    int is_full() { return sp == nrmax-1; } // definitia clasei 
-void push (int); +    void push (int); 
-int pop(); +    int pop(); 
-char *getnume() { return (char *) nume; }+    char *getnume() { return (char *) nume; }
 }; };
  
Line 214: Line 216:
  
  
-Exista doi **constructori**,​ unul cu parametru unic (numele clasei) si al doilea cu 2 parametri (dimensiune buffer si numele obiectului). Faptul ca pot exista mai multe functii constructor este o consecinta directa a **supradefinirii**+Exista doi **constructori**,​ unul cu parametru unic (numele clasei) si al doilea cu 2 parametri (dimensiune buffer si numele obiectului). Faptul ca pot exista mai multe functii constructor este o consecinta directa a **supradefinirii**.
  
-**Metodele** sunt: is_empty, is_full, push, pop, getnume, cu semnificatiile evidente.+**Metodele** sunt: is_empty, is_full, push, pop, getnume, cu semnificatiile evidente.\\ \\ 
 + 
 +Fisierul **stack.cpp** contine implementarile metodelor clasei (doar cele care nu au fost implementate in definitie):​ 
 + 
 +<code cpp stack.cpp>​ 
 +#include <​iostream>​ 
 +#include <​cstdlib>​ 
 +using namespace std; 
 +#include <​string.h>​ 
 +#include "​stack.h"​ //header-ul este inclus in fisierul sursa 
 + 
 +stack::​stack(const char *obnume) 
 +
 +  buf = new int [100];  
 +  sp = -1; nrmax = 100; 
 +  strncpy(nume,​ obnume, 9); 
 +  cout<<"​Constructor cu dimensiune implicita pentru obiectul "<<​nume<<"​\n";​ 
 +
 + 
 +stack::​stack(int dim, const char *obnume) 
 +
 +  // Constructor cu dimensiune precizata 
 +  buf = new int [nrmax = dim]; 
 +  sp = -1; 
 +  strncpy(nume,​ obnume, 9); 
 + 
 +  cout << "​Constructor cu dimensiune explicita = " << dim << " pentru obiectul " << nume << "​\n";​ 
 +
 + 
 +stack::​~stack() 
 +
 +  delete [] buf; 
 +  cout << "​Destructor pentru obiectul " << nume << "​\n";​ 
 +
 + 
 +void stack::​push(int elem) 
 +
 +  if (!is_full()) 
 +    buf[++sp] = elem; 
 + 
 +  else { 
 +    cout << "​Eroare:​ stiva plina\n";​ 
 +    exit(1); 
 +  } 
 +
 + 
 +int stack::​pop() 
 +
 +  if (!is_empty()) 
 +    return buf[sp--];​ 
 + 
 +  else { 
 +    cout << "​Eroare:​ stiva vida\n";​ 
 +    exit(1); 
 +    return -1; // Doar ca sa se respecte tipul functiei 
 +  } 
 +
 + 
 +</​code>​ 
 + 
 +Pentru a pune in evidenta secventa de creare/​distrugere a obiectelor, in functiile constructor si destructor s-au prevazut mesaje adecvate. De observat utilizarea **operatorului de rezolutie ::**, care precizeaza ca functiile respective sunt membre ale clasei **stack** (am putea avea o alta functie is_full care sa fie membra a unei clase coada). \\ \\ 
 + 
 +Fisierul **main.cpp** reprezinta programul principal (de test): 
 + 
 +<code cpp main.cpp>​ 
 +#include <​iostream>​ 
 +#include <​cstdlib>​ 
 +using namespace std; 
 +#include "​stack.h"​ // Fisier header stack 
 + 
 +stack a("​a"​);​ //variabila globala 
 + 
 +int main(int argc, char *argv[]) 
 +
 +    int i; 
 +    stack b("​b"​);​ 
 +    cout << "​\n\n"​ << "Start main\n";​ 
 + 
 +    stack c(200, "​c"​);​ 
 +    stack *pd = new stack(300, "​d"​);​ 
 + 
 +    a.push(1);​ 
 +    a.push(2);​ 
 +    pd->​push(3);​ 
 +    cout << "Pop din stiva " << pd->​getnume() << ": " << pd->​pop() << "​\n";​ 
 + 
 +// 
 +// Etc., etc. 
 +// 
 +    delete pd; // A fost alocat dinamic, deci eliberam memoria 
 +    cout << "​Sfarsit main\n";​ 
 + 
 +    system("​PAUSE"​);​ 
 +    return EXIT_SUCCESS;​ 
 +
 + 
 +</​code>​
  
 +Se defineste un obiect stack la nivel exterior **"​a"​** (cu alocare statica). El va fi creat inainte de a incepe executia functiei **main**. In main sunt **instantiate** doua obiecte (**"​b"​ si "​c"​**) si inca unul prin **alocare dinamica** (a se vedea forma **new stack(...)**). Apoi se fac cateva operatii uzuale cu stivele astfel definite. La consola se va urmari si explica secventa de mesaje din functiile constructor,​ destructor si main. De observat afisarea comoda la consola (cout) cu operatorul << (este necesar **#include <​iostream.h>​**).
  
  
poo-is/laboratoare/03.1599642753.txt.gz · Last modified: 2020/09/09 12:12 by alexandru.ionita99
CC Attribution-Share Alike 3.0 Unported
www.chimeric.de Valid CSS Driven by DokuWiki do yourself a favour and use a real browser - get firefox!! Recent changes RSS feed Valid XHTML 1.0