Opcje wyszukiwania (Strona 3 z 3)

Aby korzystać w Visual Studio ze stałych matematycznych, trzeba dołączyć do programu bibliotekę math.h:

#include <math.h>

To jednak nie wystarczy, ponieważ w tej bibliotece stałe matematyczne są definiowane pod warunkiem wcześniejszego zdefiniowania _USE_MATH_DEFINES, co widać gdy zajrzymy do pliku math.h:

#if defined(_USE_MATH_DEFINES) && !defined(_MATH_DEFINES_DEFINED)
#define _MATH_DEFINES_DEFINED

/* Define _USE_MATH_DEFINES before including math.h to expose these macro
 * definitions for common math constants.  These are placed under an #ifdef
 * since these commonly-defined names are not part of the C/C++ standards.
 */

/* Definitions of useful mathematical constants
 * M_E        - e
 * M_LOG2E    - log2(e)
 * M_LOG10E   - log10(e)
 * M_LN2      - ln(2)
 * M_LN10     - ln(10)
 * M_PI       - pi
 * M_PI_2     - pi/2
 * M_PI_4     - pi/4
 * M_1_PI     - 1/pi
 * M_2_PI     - 2/pi
 * M_2_SQRTPI - 2/sqrt(pi)
 * M_SQRT2    - sqrt(2)
 * M_SQRT1_2  - 1/sqrt(2)
 */

#define M_E        2.71828182845904523536
#define M_LOG2E    1.44269504088896340736
#define M_LOG10E   0.434294481903251827651
#define M_LN2      0.693147180559945309417
#define M_LN10     2.30258509299404568402
#define M_PI       3.14159265358979323846
#define M_PI_2     1.57079632679489661923
#define M_PI_4     0.785398163397448309616
#define M_1_PI     0.318309886183790671538
#define M_2_PI     0.636619772367581343076
#define M_2_SQRTPI 1.12837916709551257390
#define M_SQRT2    1.41421356237309504880
#define M_SQRT1_2  0.707106781186547524401

#endif  /* _USE_MATH_DEFINES */

Dlatego trzeba jeszcze w programie zawrzeć definicję _USE_MATH_DEFINES (koniecznie przed math.h, aby dołączając bibliotekę dać znać preprocesorowi, że chcemy korzystać z tych stałych.

#define _USE_MATH_DEFINES

Przykład wyświetlający wartość stałej PI:

#include <stdio.h>
#include <stdlib.h>
#define _USE_MATH_DEFINES
#include <math.h>

int main(void) {
   printf("%lf\n",M_PI);

   return EXIT_SUCCESS;
}

Utworzenie nowej klasy wiąże się z dodaniem do projektu dwóch plików - Klasa.h oraz Klasa.cpp.

W którym z tych plików najlepiej zawrzeć dyrektywy #include dołączające potrzebne biblioteki?

Plik nagłówkowy Klasa.h jest niejako wizytówką klasy. Powinien więc zawierać tylko to, co jest niezbędne do zrozumienia przeznaczenia i sposobu wykorzystania klasy.

Użytkownika klasy niekoniecznie powinny interesować szczegóły implementacji poszczególnych jej funkcjonalności.

Na przykład jeżeli w klasie dokonywane jest obliczanie wartości funkcji sinus to dla użytkownika klasy nie ma większego znaczenia czy jest to zrobione z wykorzystaniem takiej czy innej biblioteki, czy może poprzez rozwinięcie w szereg.

Dlatego wszelkie pliki nagłówkowe, które dotyczą wyłącznie implementacji, powinny być dołączone w pliku Klasa.cpp.

W pliku Klasa.h należy dołączać tylko te pliki nagłówkowe, które są niezbędne do zrozumienia przez kompilator kodu w nim zawartego.

Na przykład:

W klasie Wielokąt wyświetlamy na ekran jakieś informacje z wykorzystaniem strumieni i instrukcje to wykonujące znajdują się tylko w pliku Wielokat.cpp. Dołączenie biblioteki iostream znajdzie się więc w pliku Wielokat.cpp.

Jeżeli oprócz tego w skład klasy Wielokat wchodzą obiekty klasy Punkt i deklaracja takiego składnika klasy jest już umieszczona w pliku Wielokat.h, to dołączenie pliku Punkt.h musi zostać zawarte w pliku Wielokat.h.

Wielokat.h:

#pragma once
#include "Punkt.h"

class Wielokat {
   int ileMamWierzcholkow;
   Punkt* wierzcholki;

   // pozostałe składniki klasy...
};

Wielokat.cpp:

#include "Wielokat.h"
#include <iostream>

using namespace std;

void Wielokat::info(void) {
   cout << "Liczba wierzcholkow: " << ileMamWierzcholkow << endl;
}
//ciąg dalszy implementacji klasy...

char c;

Niektórzy programiści zastanawiają się, czy słówko char nie powinno wymawiać się [kar], skoro pochodzi od character, które wymawia się [karakter].

Widziałem nawet na YouTubie zaciekłą dyskusję na ten temat pod tutorialami jakiegoś programisty, który upierał się przy takiej właśnie wymowie.

Bardzo dobrze, że programiści zadają sobie takie pytania, ponieważ to oznacza, że kierują się logiką.

Logika jednak nie obowiązuje w języku angielskim i char wymawiamy [czar]
(pisze o tym również na swojej stronie Bjarne Stroustrup, twórca języka C++)

Na zajęciach definiowaliśmy operatory wewnątrz klas. Pierwszym argumentem każdego z operatorów był wówczas obiekt naszej klasy. Drugi argument mógł być zdefiniowany (dla operatorów dwuargumentowych jak +=, =, +) lub nie (dla operatora ++).

Ale operatory możemy również definiować poza klasami, tak jak poza klasami możemy definiować zwykłe funkcje.

Na przykład dla ćwiczenia możemy zdefiniować operator ==, który porówna nam ze sobą dwa obiekty klasy Liczba. Do uznania je za równe wystarczy nam równość pól wartosc:

bool operator==(Liczba& liczba1, Liczba& liczba2) {
    return (liczba1.dajWartosc() == liczba2.dajWartosc());
}

Tak zdefiniowany operator umieszczamy na przykład w pliku z programem głównym i możemy go już użyć w funkcji main():

if (a==b) {
    cout << "Liczby rowne" << endl;
} else {
    cout << "Liczby rozne" << endl;
}

Do operatora warto dodać informacje o tym, że jego argumenty nie zostają zmienione, czyli słówko const:

bool operator==(const Liczba& liczba1, const Liczba& liczba2) {
    return (liczba1.dajWartosc() == liczba2.dajWartosc());
}

Oczywiście powyższy przypadek można równie dobrze zdefiniować wewnątrz klasy Liczba, więc jeszcze nie widzimy uzasadnienia dla stosowania tego sposobu.

Okaże się on jednak przydatny, jeżeli będziemy chcieli na przykład pomnożyć liczbę przez walutę.

Liczba a(10, 2);
Waluta w(10, 3, "PLN", 1.0);

Dla takiego przypadku:

w = w * a;

możemy zdefiniować operator * w klasie Waluta, ponieważ "wie" ona czym jest klasa Liczba.

Nie możemy zrobić tego jednak dla takiego przypadku:

w = a * w;

Ponieważ trzeba by to zrobić w klasie Liczba, a klasa Liczba nie wie, że ma potomka Waluta.

Pozostaje nam więc zdefiniowanie tego operatora poza klasami:

Waluta operator*(const Liczba& liczba, const Waluta& waluta) {
    return Waluta(liczba.dajWartosc()*waluta.dajWartosc(), 3, waluta.dajWalute(), waluta.dajPrzelicznik());
}

Zachęcam do przetestowania tego we własnych programach.

Odniosę się jeszcze do pytania o słówko const w metodzie pobierającej napis z pola waluta.

Idąc po kolei...

W klasie Liczba mieliśmy taką sytuację, że napis, który zwracaliśmy zadeklarowany był jako wskaźnik:

char* wartoscNapis;

Pisząc metodę pobierzWartoscNapis, mogliśmy to zrobić w ten sposób:

inline char* pobierzWartoscNapis(void) {return wartoscNapis;};

Jeżeli chcieliśmy zaznaczyć, że metoda ta ma nie zmieniać zawartości obiektu, stosowaliśmy po jej nazwie słówko const:

inline char* pobierzWartoscNapis(void) const {return wartoscNapis;};

I rzeczywiście, zawartością obiektu jest w tym przypadku pojedynczy wskaźnik, więc pobierając go z tej metody nie będziemy w stanie zmienić go na zewnątrz - więc nie będziemy w stanie zmienić zawartości obiektu - wszystko się zgadza

Natomiast w klasie Waluta, pole przechowujące napis waluty mamy zdefiniowane inaczej, jako statyczną tablicę:

char waluta[4];

Więc w obiekcie tym razem "siedzi" cały napis, a nie wskaźnik na jakiś zewnętrzny napis, jak to było w przypadku klasy Liczba.

Pisząc metodę pobierzWalute, możemy zacząć tak:

inline char* pobierzWalute(void) {return waluta;};

I wszystko na tym etapie działa.

Jeżeli chcemy zasygnalizować, że ta metoda nie ma zmieniać zawartości obiektu, próbujemy to zrobić w ten sposób (analogicznie jak w klasie Liczba):

inline char* pobierzWalute(void) const {return waluta;};

Wówczas kompilator zgłasza błąd. Dlaczego?

Dzieje się tak ponieważ pomimo tego, że zadeklarowaliśmy metodę jako const, to mając wskaźnik na napis waluta, moglibyśmy zmienić ten napis, więc moglibyśmy zmienić zawartość obiektu (a chcemy poprzez const wymusić, że tego nie będzie dało się zrobić).

Dlatego w tym przypadku, konieczne jest jeszcze dodanie słówka const z przodu, aby zasygnalizować, że zwracamy wskaźnik na stały napis i uniemożliwić zmianę tego napisu (napis ten jest przecież elementem obiektu, a my zawartość obiektu chcemy ochronić przed zmianą):

inline const char* pobierzWalute(void) const {return waluta;};

Dopiero teraz kompilator przestaje sygnalizować błąd.

Wracając do klasy Liczba...

Jeżeli mamy zadeklarowaną metodę pobierającą napis w ten sposób:

inline char* pobierzWartoscNapis(void) const {return wartoscNapis;};

To pomimo tego, że taka deklaracja uniemożliwia zmianę pola obiektu (czyli wskaźnika), to sam napis, na który ten wskaźnik wskazuje moglibyśmy zmienić, na przykład tak:

liczba1.pobierzWartoscNapis()[1] = 'a';

Dlatego aby dodatkowo zabezpieczyć się przed taką operacją, możemy zastosować słówko const w deklaracji typu zwracanego przez metodę:

inline const char* pobierzWartoscNapis(void) const {return wartoscNapis;};

Zachęcam do przetestowania tego we własnych programach.