Opis programu

0
 
#include <iostream> // zastosowanie podstawowej biblioteki wejścia i wyjścia

using namespace std;

class punkt    // stworzyłem klase o nazwie punkt 
{
    static int nrP;
    int nr;
    double x, y;
public:                                                         // zastosowałem dostęp publiczny 
    punkt(double x = .0, double y = .0):
        x(x),y(y),nr(nrP+1){nrP++;}

    double X(){return x;}
    double Y(){return y;}

    int wyswietlpkt(){return nr;}      // funkcja służąca do wyświetlenia
};

int punkt::nrP;

void wypisz(punkt pkt)                                          // funkcja wypisująca 
{
    cout<<"Nr Punktu: "<<pkt.wyswietlpkt()<<endl;
    cout<<"Wspolrzedna X: "<<pkt.X()<<endl;
    cout<<"Wspolrzedna Y: "<<pkt.Y()<<endl;
}

int main()
{
    punkt p1, p2(1., 3.);
    wypisz(p2);
    return 0;
}

Witajcie dopiero zacząłem studia z informatyką i mam problem z opisem programu. Tematy które przerobiliśmy to
Klasy , Przestrzenie nazw ,Inicjalizacja ,Konwersje automatyczne. Czy możecie sprawdzić mi to co napisałem w komentarzach programu. Jeśli ktoś może proszę o uzupełnienie komentarzy w miejscach w których są oraz tam gdzie ich nie ma bo nie wiem jak to opisać. Dziękuje z góry.

0

jest ok.

0

cout<<"Nr Punktu: "<<pkt.wyswietlpkt()<<endl; //informujemy kompilator, że chcemy wejść do przestrzeni nazw std
//oraz skorzystać ze znajdującej się operacji wyświetlenia numeru punktu

cout<<"Wspolrzedna X: "<<pkt.X()<<endl;         // wyświetlenie współrzędnej x
cout<<"Wspolrzedna Y: "<<pkt.Y()<<endl;         // wyświetlenie współrzędnej y

}

0

jest gładko mówiąc słabo, wyżej dodałem dodatkowe komentarze. Pomoże ktoś ?

0

nie no, tyle co masz w tym kodzie na górze starczy, nie musisz komentować każdej linii bo to by było bardziej komiczne niż przydatne : D
//edit jeśli rozumiesz kod to nie masz się czego obawiać.

0
public:
    punkt(double x = .0, double y = .0):
        x(x),y(y),nr(nrP+1){nrP++;}

    double X(){return x;}
    double Y(){return y;}

    int wyswietlpkt(){return nr;}

......

void wypisz(punkt pkt)
{
    cout<<"Nr Punktu: "<<pkt.wyswietlpkt()<<endl;  
                                                    
    cout<<"Wspolrzedna X: "<<pkt.X()<<endl;       
    cout<<"Wspolrzedna Y: "<<pkt.Y()<<endl;        
}

Najbardziej mi zależy na opisaniu powyższych linijek bo właśnie to było uzupełnieniem programu i potrzebuje opisu tych linijek

0
class Point {
  static unsigned count;
  unsigned numb;
  double x, y;
public:
  Point() : x( 0.0 ), y ( 0.0 ), numb( ++count ) { }        // konstruktor domyślny
  Point( const double& x, const double& y ) : x( x ), y( y ), numb( ++count ) { }     // konstruktor inicjalizujący
  Point( const Point& source ) : x( source.x ), y( source.y ) { }    // konstruktor kopiujący
  ~Point() { --count; }     // destruktor
  Point& operator=( const Point& source ) {     // operator przypisania
    x = source.x;
    y = source.y;
    return *this;
  }
  // gettery i settery; inline bo trywialne
    // const - bo nie zmieniają stanu obiektu
      inline double GetX() const { return x; }
      inline double GetY() const { return y; }
      inline unsigned GetID() const { return numb; }
  inline void SetX( double value ) { x = value; }
  inline void SetY( double value ) { y = value; }

  // wypisanie do strumienia
  friend std::ostream& operator<<( std::ostream& stream, const Point& point ) {
    stream << "Numer: " << point.GetID() << "\nWsp.X: " << point.GetX() << "\n" << "Wsp.Y: " << point.GetY() << "\n\n";
    return stream;
  }
};
unsigned Point::count = 0;

Z tym, że dla mnie to bardziej pasuje na zwyczajną strukturę i tworzenie takich klas to przerost formy nad treścią.

0
class punkt                                         // klasa o nazwie punkt
{
    static int nrP;
    int nr;                                         // deklarujemy dane składowe tej klasy(różnego typu
    double x, y;
public:                                             //Określam dostęp jako publiczny (public), dzięki temu umożliwiamy dostęp do składników klasy poza jej ciałem.

    punkt(double x = .0, double y = .0)         // utworzyłem konstruktor 
    :                                               //rozpoczecie listy inicjalizacyjnej
        x(x),y(y),nr(nrP+1){nrP++;}                    //inicjalizacja zmiennych 

    double X(){return x;}
    double Y(){return y;}

    int wyswietlpkt(){return nr;}
};

int punkt::nrP;

void wypisz(punkt pkt)                              // funkcja służąca do wyświetlenia

{
    cout<<"Nr Punktu: "<<pkt.wyswietlpkt()<<endl;   //informujemy kompilator, że chcemy wejść do przestrzeni nazw std
                                                    //oraz skorzystać ze znajdującej się operacji wyświetlenia numeru punktu

    cout<<"Wspolrzedna X: "<<pkt.X()<<endl;         // wyświetlenie współrzędnej x
    cout<<"Wspolrzedna Y: "<<pkt.Y()<<endl;         // wyświetlenie współrzędnej y
}

int main()
{
    punkt p1, p2(1., 3.);
    wypisz(p2);
    return 0;
}

Udało mi się opisać w ten sposób, czy ktoś z was może mi sprawdzić i ew nanieść poprawki

0

Skąd to //informujemy kompilator, że chcemy wejść do przestrzeni nazw std się wzięło? Nie widzę tam "informacji o wejściu" do przestrzeni nazw std.

1 użytkowników online, w tym zalogowanych: 0, gości: 1