Języki programowania

// ---------- C++ ----------
#include <iostream>
int main() {
  int a = 5, b = 3;
  std::cout << "Suma: " << a + b << std::endl;
  return 0;
}

// ---------- Java ----------
public class Program {
  public static void main(String[] args) {
      int a = 5, b = 3;
      System.out.println("Suma: " + (a + b));
  }
}

// ---------- C# ----------
using System;
class Program {
  static void Main() {
      int a = 5, b = 3;
      Console.WriteLine("Suma: " + (a + b));
  }
}

# ---------- Python ----------
a = 5
b = 3
print("Suma:", a + b)

# Etapy rozbite na osobne polecenia (kompilator g++):

g++ -E  main.cpp -o main.i      # 1. tylko preprocesor  -> tekst
g++ -S  main.i   -o main.s      #    (opcjonalnie) kod w asemblerze
g++ -c  main.cpp -o main.o      # 2. kompilacja         -> plik obiektowy
g++ main.o funkcje.o -o program # 3. konsolidacja       -> plik wykonywalny

# W praktyce robi się to jednym poleceniem - g++ sam wywoła wszystkie etapy:
g++ main.cpp funkcje.cpp -o program
./program

# Typowe komunikaty i etap, na którym powstaja:
# "expected ';' before '}' token"        -> kompilacja (blad skladniowy)
# "undefined reference to 'suma(int)'"   -> konsolidacja (brak definicji)
# "No such file or directory: iostream"  -> preprocesor (brak naglowka)

#include <iostream>
#include <climits>
using namespace std;

int main() {
  cout << "sizeof(char)   = " << sizeof(char)   << " B" << endl;
  cout << "sizeof(int)    = " << sizeof(int)    << " B" << endl;
  cout << "sizeof(float)  = " << sizeof(float)  << " B" << endl;
  cout << "sizeof(double) = " << sizeof(double) << " B" << endl;
  cout << "INT_MIN = " << INT_MIN << ", INT_MAX = " << INT_MAX << endl;
  return 0;
}

/* Typowe wyjscie na 64-bitowym PC:
sizeof(char)   = 1 B
sizeof(int)    = 4 B
sizeof(float)  = 4 B
sizeof(double) = 8 B
INT_MIN = -2147483648, INT_MAX = 2147483647
*/

int a;              // deklaracja bez inicjalizacji - wartosc SMIECIOWA
int b = 10;         // deklaracja z inicjalizacja (kopiujaca)
int c(20);          // inicjalizacja nawiasowa
int d{30};          // inicjalizacja klamrowa (od C++11, najbezpieczniejsza)
int e = 0, f = 0;   // dwie zmienne w jednej instrukcji

double cena = 19.99;
char   ocena = '5';   // pojedynczy znak - apostrofy
string imie = "Anna"; // napis - cudzyslowy
bool   zdany = true;

// int 2liczba;   // BLAD: nazwa nie moze zaczynac sie od cyfry
// int int;       // BLAD: slowo kluczowe nie moze byc nazwa
// int moja-zmienna; // BLAD: myslnik jest operatorem odejmowania

# ---- odpowiednik w Pythonie: typu sie nie podaje ----
# a = 10
# cena = 19.99
# imie = "Anna"
# zdany = True

#include <iostream>
using namespace std;

int licznikGlobalny = 0;        // ZASIEG GLOBALNY

void test() {
  int lokalna = 0;            // ZASIEG LOKALNY - tworzona od nowa
  static int statyczna = 0;   // ZASIEG STATYCZNY - tworzona raz

  lokalna++;
  statyczna++;
  licznikGlobalny++;

  cout << "lokalna=" << lokalna
       << " statyczna=" << statyczna
       << " globalna=" << licznikGlobalny << endl;
}

int main() {
  test();
  test();
  test();
  return 0;
}

/* WYJSCIE:
lokalna=1 statyczna=1 globalna=1
lokalna=1 statyczna=2 globalna=2
lokalna=1 statyczna=3 globalna=3
*/

const double PI = 3.14159;        // C++: stala z typem, zalecana
constexpr int MAX = 100;          // C++11: wyliczana na etapie kompilacji
#define STAWKA_VAT 0.23           // makro preprocesora - bez typu, styl z C

// PI = 3.0;   // BLAD KOMPILACJI: assignment of read-only variable 'PI'

// Java:   final double PI = 3.14159;
// C#:     const double PI = 3.14159;
// Python: PI = 3.14159   (konwencja WIELKIE_LITERY - jezyk nie chroni)

#include <iostream>
using namespace std;

int main() {
  int a = 7, b = 2;

  cout << a / b << endl;                    // 3    <- dzielenie CALKOWITE
  cout << a % b << endl;                    // 1    <- reszta z dzielenia

  double w1 = a / b;                        // najpierw 7/2 = 3, potem 3.0
  cout << w1 << endl;                       // 3     PULAPKA

  double w2 = (double)a / b;                // rzutowanie JAWNE (styl C)
  cout << w2 << endl;                       // 3.5   POPRAWNIE

  double w3 = static_cast<double>(a) / b;   // rzutowanie JAWNE (styl C++)
  cout << w3 << endl;                       // 3.5   POPRAWNIE

  double w4 = a / 2.0;                      // 2.0 jest double -> konwersja
  cout << w4 << endl;                       // 3.5   NIEJAWNA konwersja b

  int x = 3.99;                             // OBCIECIE, nie zaokraglenie
  cout << x << endl;                        // 3

  int y = -3.99;
  cout << y << endl;                        // -3   (obciecie w strone zera)

  char znak = 65;                           // kod ASCII 65
  cout << znak << endl;                     // A

  int kod = 'A';
  cout << kod << endl;                      // 65

  float f = 0.1f;
  double d = 0.1;
  cout << (f == d) << endl;                 // 0 (falsz!) - inna precyzja
  return 0;
}

int a = 2, b = 3, c = 4;

int w1 = a + b * c;        // 2 + 12 = 14   (mnozenie przed dodawaniem)
int w2 = (a + b) * c;      // 5 * 4  = 20   (nawias zmienia kolejnosc)
int w3 = 10 % 3 + 1;       // 1 + 1  = 2    (modulo ma priorytet jak *)
int w4 = 17 / 5 * 5;       // 3 * 5  = 15   (nie 17! dzielenie calkowite)

// Preinkrementacja kontra postinkrementacja - ulubione pytanie:
int i = 5;
int x = ++i;   // NAJPIERW zwieksz, POTEM przypisz -> i = 6, x = 6
int j = 5;
int y = j++;   // NAJPIERW przypisz, POTEM zwieksz -> j = 6, y = 5

// Skrocone przypisania:
int n = 10;
n += 5;   // n = n + 5  -> 15
n *= 2;   // n = n * 2  -> 30
n %= 7;   // n = n % 7  -> 2

// Skrocone wartosciowanie (short-circuit):
// jesli pierwszy warunek falszywy, drugi NIE jest sprawdzany
if (b != 0 && a / b > 1) { /* bezpieczne - nie bedzie dzielenia przez zero */ }

#include <iostream>
#include <vector>
using namespace std;

int main() {
  // --- TABLICA STATYCZNA: rozmiar znany podczas kompilacji, pamiec na stosie
  int oceny[5] = {5, 4, 3, 5, 2};
  cout << oceny[0] << endl;   // 5   - pierwszy element ma indeks 0
  cout << oceny[4] << endl;   // 2   - ostatni ma indeks 4, nie 5!
  // oceny[5] -> WYJSCIE POZA TABLICE, brak kontroli, nieokreslone zachowanie

  int suma = 0;
  for (int i = 0; i < 5; i++) suma += oceny[i];
  cout << "Srednia: " << (double)suma / 5 << endl;   // 3.8

  // --- TABLICA DWUWYMIAROWA
  int macierz[2][3] = {{1, 2, 3}, {4, 5, 6}};
  cout << macierz[1][2] << endl;   // 6

  // --- TABLICA DYNAMICZNA: rozmiar podany w czasie dzialania, pamiec na stercie
  int n;
  cout << "Podaj rozmiar: ";
  cin >> n;
  int* tab = new int[n];       // przydzial pamieci
  for (int i = 0; i < n; i++) tab[i] = i * i;
  cout << tab[n - 1] << endl;
  delete[] tab;                // ZWOLNIENIE - inaczej wyciek pamieci
  tab = nullptr;

  // --- WEKTOR: tablica dynamiczna z biblioteki standardowej, sama sie sprzata
  vector<int> v = {10, 20, 30};
  v.push_back(40);
  cout << v.size() << endl;    // 4
  cout << v.at(10) << endl;    // at() rzuca wyjatek out_of_range - kontrola!
  return 0;
}

int liczba = 42;

int* wsk = &liczba;   // wsk przechowuje ADRES zmiennej liczba
int& ref = liczba;    // ref to DRUGA NAZWA tej samej zmiennej

cout << liczba << endl;   // 42
cout << *wsk   << endl;   // 42  - dereferencja: wartosc spod adresu
cout << ref    << endl;   // 42  - alias, bez zadnych gwiazdek
cout << wsk    << endl;   // np. 0x7ffd3c... - sam adres

*wsk = 100;               // zapis przez wskaznik
cout << liczba << endl;   // 100 - zmienila sie oryginalna zmienna

ref = 7;                  // zapis przez referencje
cout << liczba << endl;   // 7

int inna = 1;
wsk = &inna;              // OK - wskaznik mozna przestawic
// int& ref2;             // BLAD - referencja musi byc zainicjalizowana

#include <iostream>
using namespace std;

void przezWartosc(int x) {      // x to KOPIA argumentu
  x = x * 2;
  cout << "  wewnatrz przezWartosc:   x = " << x << endl;
}

void przezReferencje(int& x) {  // x to ALIAS argumentu (ampersand przy typie)
  x = x * 2;
  cout << "  wewnatrz przezReferencje: x = " << x << endl;
}

void przezWskaznik(int* x) {    // x to ADRES argumentu
  *x = *x * 2;
  cout << "  wewnatrz przezWskaznik:   *x = " << *x << endl;
}

int main() {
  int a = 5;
  cout << "przed: a = " << a << endl;
  przezWartosc(a);
  cout << "po przezWartosc: a = " << a << endl;

  int b = 5;
  przezReferencje(b);
  cout << "po przezReferencje: b = " << b << endl;

  int c = 5;
  przezWskaznik(&c);          // przekazujemy ADRES
  cout << "po przezWskaznik: c = " << c << endl;
  return 0;
}

/* WYJSCIE:
przed: a = 5
wewnatrz przezWartosc:   x = 10
po przezWartosc: a = 5          <-- ORYGINAL NIEZMIENIONY
wewnatrz przezReferencje: x = 10
po przezReferencje: b = 10      <-- ORYGINAL ZMIENIONY
wewnatrz przezWskaznik:   *x = 10
po przezWskaznik: c = 10        <-- ORYGINAL ZMIENIONY
*/

std::exception                 (korzen hierarchii w C++)
 |
 +-- std::logic_error        blad logiki, dalo sie go przewidziec
 |      +-- std::invalid_argument   zly argument
 |      +-- std::out_of_range       indeks poza zakresem (np. vector::at)
 |      +-- std::domain_error
 |
 +-- std::runtime_error      blad wykrywalny dopiero w czasie dzialania
        +-- std::overflow_error     przepelnienie
        +-- std::range_error

// Kolejnosc blokow catch MA ZNACZENIE:
// catch (const std::exception& e)      <- gdyby stal pierwszy, przechwycilby WSZYSTKO
// catch (const std::out_of_range& e)   <- ten nigdy by sie nie wykonal

#include <iostream>
#include <stdexcept>
#include <string>
using namespace std;

// WLASNY wyjatek - dziedziczy po std::runtime_error
class BladDzielenia : public runtime_error {
public:
  BladDzielenia(const string& komunikat)
      : runtime_error(komunikat) {}
};

double podziel(double a, double b) {
  if (b == 0) {
      throw BladDzielenia("Proba dzielenia przez zero!");  // RZUCENIE
  }
  return a / b;
}

int sprawdzWiek(int wiek) {
  if (wiek < 0 || wiek > 120) {
      throw invalid_argument("Wiek poza zakresem 0-120");
  }
  return wiek;
}

int main() {
  try {
      cout << podziel(10, 2) << endl;    // 5
      cout << sprawdzWiek(20) << endl;   // 20
      cout << podziel(10, 0) << endl;    // tu leci wyjatek
      cout << "Ta linia sie NIE wykona" << endl;
  }
  catch (const BladDzielenia& e) {       // najpierw typ SZCZEGOLOWY
      cout << "Blad dzielenia: " << e.what() << endl;
  }
  catch (const invalid_argument& e) {
      cout << "Zly argument: " << e.what() << endl;
  }
  catch (const exception& e) {           // na koncu typ OGOLNY
      cout << "Inny blad: " << e.what() << endl;
  }
  catch (...) {                          // lapie absolutnie wszystko
      cout << "Nieznany blad" << endl;
  }

  cout << "Program dziala dalej." << endl;
  return 0;
}

/* WYJSCIE:
5
20
Blad dzielenia: Proba dzielenia przez zero!
Program dziala dalej.
*/

# ---- Ten sam mechanizm w Pythonie, z blokami else i finally ----
class BladDzielenia(Exception):
  pass

def podziel(a, b):
  if b == 0:
      raise BladDzielenia("Proba dzielenia przez zero!")
  return a / b

try:
  wynik = podziel(10, 0)
except BladDzielenia as e:
  print("Blad dzielenia:", e)
except ValueError as e:
  print("Zla wartosc:", e)
else:
  print("Wynik:", wynik)      # tylko gdy NIE bylo wyjatku
finally:
  print("Ten blok wykona sie ZAWSZE")

// ---- Java / C#: schemat identyczny ----
// try { ... }
// catch (ArithmeticException e) { System.out.println(e.getMessage()); }
// finally { plik.close(); }

#include <iostream>
#include <string>
using namespace std;

int main() {
  int wiek;
  string imie, calaLinia;

  cout << "Podaj imie: ";
  cin >> imie;              // czyta do pierwszego BIALEGO ZNAKU (spacji)

  cout << "Podaj wiek: ";
  cin >> wiek;

  cin.ignore();             // usuwa znak konca linii zostawiony przez cin
  cout << "Podaj adres: ";
  getline(cin, calaLinia);  // czyta CALA linie razem ze spacjami

  cout << "Witaj, " << imie << ", masz " << wiek << " lat." << endl;
  cerr << "To trafia na strumien bledow, nie na standardowe wyjscie" << endl;

  // Kontrola poprawnosci danych wejsciowych:
  if (cin.fail()) {
      cout << "Podano dane w zlym formacie!" << endl;
      cin.clear();          // kasuje flage bledu strumienia
  }
  return 0;
}

# ---- Python ----
# imie = input("Podaj imie: ")
# wiek = int(input("Podaj wiek: "))   # input zwraca TEKST, trzeba rzutowac
# print(f-string albo print("Witaj,", imie))

#include <iostream>
#include <fstream>
#include <string>
using namespace std;

int main() {
  ifstream plik("dane.txt");          // 1. OTWARCIE do odczytu

  if (!plik.is_open()) {              // 2. SPRAWDZENIE, czy sie udalo
      cerr << "Blad: nie mozna otworzyc pliku dane.txt" << endl;
      return 1;                       // kod wyjscia rozny od zera = blad
  }

  string linia;
  int numer = 0;
  while (getline(plik, linia)) {      // 3. ODCZYT linia po linii
      numer++;                        //    getline zwraca falsz na koncu pliku
      cout << numer << ": " << linia << endl;
  }

  plik.close();                       // 4. ZAMKNIECIE - zwolnienie zasobu
  cout << "Wczytano linii: " << numer << endl;
  return 0;
}

/* Wariant z wyjatkiem zamiast kodu powrotu:
 ifstream plik("dane.txt");
 if (!plik) throw runtime_error("Nie mozna otworzyc pliku dane.txt");
*/

#include <fstream>
#include <iostream>
#include <string>
using namespace std;

int main() {
  // --- ZAPIS: tryb domyslny KASUJE dotychczasowa zawartosc pliku
  ofstream wy("wyniki.txt");
  if (!wy) {
      cerr << "Nie mozna utworzyc pliku wyniki.txt" << endl;
      return 1;
  }
  wy << "Jan Kowalski;5" << endl;
  wy << "Anna Nowak;4" << endl;
  wy.close();

  // --- DOPISANIE na koncu istniejacego pliku
  ofstream dopisz("wyniki.txt", ios::app);
  dopisz << "Piotr Zielinski;3" << endl;
  dopisz.close();

  // --- ODCZYT liczb do konca pliku
  ifstream we("liczby.txt");
  if (!we.is_open()) return 1;
  int x, suma = 0, ile = 0;
  while (we >> x) {          // petla konczy sie na koncu pliku lub blednych danych
      suma += x;
      ile++;
  }
  we.close();
  if (ile > 0) cout << "Srednia: " << (double)suma / ile << endl;
  return 0;
}

# ---- Python: konstrukcja with sama zamyka plik, takze przy wyjatku ----
# try:
#     with open("dane.txt", "r", encoding="utf-8") as f:
#         for numer, linia in enumerate(f, start=1):
#             print(numer, linia.strip())
# except FileNotFoundError:
#     print("Nie znaleziono pliku dane.txt")