SOISK - SYSTEMY OPERACYJNE I SIECI KOMPUTEROWE
Tomasz Puchała

Przykłady C,C++

#include<stdio.h>
#include<stdlib.h>
#include<string>

static int tab1[13] = ‹ 1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1 ›;
static char* tab2[13] = ‹ "M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I" ›;

void zamien( int x, int n )

int g = x/(tab1[n]);
if( g > 0 )
for( int i = 0; i < g; i++ )‹
printf("%s", tab2[n] );

x = x - g*(tab1[n]);
if( x > 0 && n < 13 )
zamien( x, n+1 ); /* n +1 -> kiedy zaczynasz od 1000; n-1 -> kiedy zaczynasz od 1 */


int main()

/* przykladowa liczba to 1212 */
zamien( 1212, 0 ); /* 0 -> zaczynaj od 1000 ;12 -> zaczynaj od 1 */
printf("n");

#if SYSTEM==SYSV
system("PAUSE");
#else
return 0;
#endif

____________________________________________________________________________________________________




tablica dwuwymiarowa jest przechowywana w postaci "n" tablic jednowymiarowych (liniowo). Oto poprawiony kod,


#include<stdio.h>
#include <stdlib.h>
#include <time.h>

int main()
{
{
int **tab,n,m,i,j,x;

printf("Podaj liczbe wierszy");
scanf("%d", &n);

printf("Podaj liczbe kolumn");
scanf("%d", &m);

printf("Podaj maxymalna liczbe w tablicy");
scanf("%d", &x);

srand(time(NULL));
//wylosowanie tablicy
for(i=0; i<n; i++)
{
for(j=0; j<m; j++)
{

tab[i] = rand() % x+1;
}

}
//wypisanie tablicy
printf("Wylosowana tablica to:n");
for(i=0; i<n; i++)
{
for(j=0; j<m; j++)

printf("%5d", tab[i]);

printf("n");
}
free(tab);
}
return EXIT_SUCCESS;
}





Program na przeliczanie wysokosci podanej
w stopach na wysokosc w metrach.
Cwiczymy tu operacje wczytywania z klawiatury
i wypisywania na ekranie
------------------------------------------------------------*/
#include <iostream>
int main()
{
    int         stopy;                // Do przechowania danej wejsciowej
    double     metry;                                    // Do wpisania wyniku
    double     przelicznik = 0.3;                    // przelicznik:
                                                //        stopy na metry
   
    std::cout << "Podaj wysokosc w stopach: ";
    std::cin >> stopy;                                // przyjecie danej
                                                    //        z klawiatury
   
    metry = stopy * przelicznik;            // wlasciwe przeliczenie
   
    std::cout << "n";         //to samo, co std::cout << std::endl;
   
    // -----wypisanie wynikow ---------
    std::cout << stopy << " stop - to jest: "
        << metry << " metrown";
}
____________________________________________________________________________________

#include <iostream>
int main()
{
  int wys, punkty_karne;          // definicja dwóch zmiennych
                   // typu int. Obie są tego samego typu więc
                  // wystarczy przecinek odzielający nazwy

  std::cout << "Na jakiej wysokosci lecimy ? [w metrach]: ";
  std::cin >> wys;

  // ----------- rozważamy sytuację ------------------------
  if(wys < 500)
  {
    std::cout << "n" << wys << " metrow to za nisko !n";
    punkty_karne = 1;
  }
  else
  {
    std::cout << "nNa wysokosci " << wys
              << " metrow jestes juz bezpieczny n";
    punkty_karne = 0;
  }

   // -------------- ocena Twoich wyników ----------------
   std::cout << "Masz " << punkty_karne
             << " punktow karnych n";
   if(punkty_karne)std::cout << "Popraw sie !";
 }

____________________________________________________________________________________




#include <iostream>
int main()
{
    int ile;
 
    std::cout << "Ile gwiazdek ma miec kapitan ? : ";
    std::cin >> ile;
 
    std::cout << "n No to narysujmy wszystkie "
                    << ile << " : ";
 
    // pętla while rysująca gwiazdki
    while(ile)
    {
        std::cout << "*";
        ile = ile - 1;
    }
    // na dowód, że miał prawo przerwać pętlę
    std::cout << "n Teraz zmienna ile ma wartosc " << ile;
 }

____________________________________________________________________________________

#include <iostream>
int main()
{
    char litera;
    do {
        std::cout << "Napisz jakas litere: ";
        std::cin >> litera;
        std::cout << "n Napisales: " << litera << " n";
    }while(litera != 'K');                                         // `1
 
    std::cout << "n Skoro Napisales K to konczymy !";
}

____________________________________________________________________________________


#include <iostream>
int main()
{
    std::cout << "Stewardzie, ilu leci pasazerów ? ";

    int    ile;                        // liczba pasażerów
    std::cin >> ile;

     int i;                            // licznik obiegów pętli    `1
    for(i = 1 ; i <= ile ; i = i + 1)                 // `2
    {
        std::cout     << "Pasazer nr " << i
                    << " prosze zapiac pasy ! n";
    }
 
    std::cout << "Skoro wszyscy juz zapieli, to ladujemy. ";
}



____________________________________________________________________________________



#include <iostream>
int main()
{
int i     ;                            // definicja obiektu
int k, n, m, j;
 
    i = 5;
    k = i + 010;                        // czyli:  i + 8
 
    std::cout << "k= " << k << std::endl;
 
    m = 100;
    n = 0x100;
    j = 0100;
 
    std::cout << "m+n+j= " << (m+n+j) << "n";
 
    std::cout     << "Wypisujemy: "   
                    << 0x22
                    << " " << 022
                    << " " << 22 << "n";
}
____________________________________________________________________________________

#include <iostream>          // tu są deklaracje nazw z biblioteki iostream
using namespace std;        // `1
int main()
{
    cout << "Witamy na pokladzie";         // <- tu używamy nazwy cout 2
}
____________________________________________________________________________________

#include <iostream>
using namespace std ;

int k = 33 ;          //  zmienna globalna (obiekt typu  int)
/*******************************************************/
int main()
{
     cout << "Jestem w main , k =" << k << "n" ;
     {
          int k = 10 ;                    // zmienna lokalna
          cout << "po lokalnej definicji k ="
               <<     k                                        //
               << "nale  obiekt globalny  k ="
               << ::k   ;                                   //
     }
     cout << "nPoza blokiem k =" << k << endl ;

 }

____________________________________________________________________________________

#include <iostream>
using namespace std ;

int main()
{
int i ;
     for(i = 0 ; i < 64 ; i = i + 1)
     {
          if( i %                //
          {                         //
               cout << "t" ;       // wypis tabulatora
          }
          else
          {                         //
               cout << "n" ;            // przejscie do nowej linii
          }
          cout << i ;               //
     }

 }

____________________________________________________________________________________


#include <iostream>
using namespace std ;

int main()
{
     int      a = 5,
          b = 5,
          c = 5,
          d = 5 ;

          cout << "A oto wartosc poszczegolnych wyrazenn"
               << "(nie mylic ze zmiennymi)n" ;

          cout << "++a = " << ++a << endl
               << "b++ = " << b++ << endl
               << "--c = " << --c << endl
               << "d-- = " << d-- << endl ;

          // teraz sprawdzamy co jest obecnie w zmiennych

          cout << "Po obliczeniu tych wyrazen, same "
                    "zmienne maja wartoscin"
               << "a = " << a << endl
               << "b = " << b << endl
               << "c = " << c << endl
               << "d = " << d << endl ;

 }

____________________________________________________________________________________

#include <iostream>
using namespace std;
//**********************************************************
int main()
{
    int a;
    cout << "Musisz odpowiedziec TAK lub NIE n"
        << "jesli TAK, to napisz 1 n"
        << "jesli NIE to napisz 0 n"
        << " Rozumiesz ? Odpowiedz: ";
   
    cin >> a;                            // 2
   
    cout << "Odpowiedziales: "
        << ( a? "TAK" : "NIE" )     // 1
        << ", prawda ? ";
}


____________________________________________________________________________________


#include <iostream>
using namespace std;
int main()
{
int mm;
 
    cout << "Godzina prawdy. W tym komputerze "
            << "poszczególne typyn"
            << "maja nastepujace rozmiary w bajtach: n";
 
    cout << "typ char: t"     << sizeof(char)         << endl;
    cout << "typ int: t"     << sizeof(int)         << endl;
    cout << "typ short: t" << sizeof(short)     << endl;
    cout << "typ long: t"     << sizeof(long)         << endl;
    cout << "typ float: t"     << sizeof(float)     << endl;
    cout << "typ double: t"     << sizeof(double)     << endl;
    cout << "typ long double: t"<< sizeof(long double)
            << endl;
 
    cout << "Nasz obiekt lokalny mm ma rozmiar: "
             << sizeof(mm) << endl;
}


____________________________________________________________________________________

#include <iostream>
using namespace std ;


int kukulka(int ile);           //
/**************************************************/
int   main()
{
    int m = 20 ;
    cout << "Zaczynamy" << endl ;
   
    m = kukulka(5) ;             //
    cout << "nNa koniec m = " << m ;               //
   
   
}
/**************************************************/
int kukulka(int ile)                              //
{                                                  //
    int i ;
    for(i = 0 ; i < ile ; i++)
    {
        cout << "Ku-ku ! " ;
    }
    return 77 ;                                   //
}                                                  //


____________________________________________________________________________________

#include <iostream>
using namespace std;

long potega(int stopien, long liczba);
//************************************************************
int main()
{
    int pocz, koniec;
 
    cout << "Program na obliczanie poteg liczb"
            << "calkowitychn"
            << "z zadanego przedzialu n"
            << "Podaj poczatek przedzialu: ";
    cin >> pocz;
 
    cout << "nPodaj koniec przedzialu: ";
    cin >> koniec;
 
    // pętla drukująca wyniki z danego przedziału
    for(int i = pocz ; i <= koniec ; i++)
    {
        cout << i
                << " do kwadratu = "
                << potega(2, i)                             // <-wywołanie funkcji
                << " a do szescianu = "
                << potega(3, i)                         // <-wywołanie funkcji
                << endl;
    }
}
//*************************************************************
long potega(int stopien, long liczba)
{
    long wynik = liczba;
    for(int i = 1 ; i < stopien ; i++)
    {
        wynik = wynik * liczba;
        // zwięźlej można zapisać to samo jako:  wynik *= liczba;
    }
    return wynik;                                                     // `1
}
____________________________________________________________________________________

#include <iostream>
using namespace std;

void zer(int wart, int &ref);                                      
/************************************************************/
int main()
{
    int     a = 44, b = 77;
   
    cout << "Przed wywolaniem funkcji: zer n";
    cout << "a = " << a << ", b = " << b << endl;
   
    zer(a, b);                                                             
   
    cout << "Po powrocie z funkcji: zer n";
    cout << "a = " << a << ", b = " << b << endl;         
}
//*************************************************************
void zer(int wart, int &ref)   
{
    cout << "tW funkcji zer przed zerowaniem n"    ;
    cout << "twart = " << wart << ", ref = "
        << ref << endl;                                          
   
    wart = 0;
    ref = 0;                                                                 
   
    cout << "tW funkcji zer po zerowaniu n";   
    cout << "twart = " << wart << ", ref = "
        << ref << endl;                                          
   
}                                                                             


____________________________________________________________________________________


#include <iostream>
using namespace std ;

void funkcja(int a = 2, int  = 6);                    //
//-----------------
int kwadrat(int x) { return x * x; }              //
int globalny1 = 32 ;                                     //
//*************************************************************
int main()
{
    funkcja();                                                             //
   
    {      // ¬ otwarcie lokalnego zakresu  Î
        cout << "--- Jestesmy w zakresie lokalnymn";
       
        // wywołujemy jeszcze "po staremu"
        funkcja();                                                 // 
       
        int lokalny1 = 2 ;                                      //
       
        // void funkcja(int a = 3, int b);            //<- błąd 
        // void funkcja(int a, int b = lokalny1);    //<- błąd 
       
        void funkcja(int a, int  b = ;                        // 
       
        // od tej pory "po staremu" wywołać już nie można
        //funkcja();                                            // <- błąd !      
       
        funkcja(7);                                                   //
       
        globalny1 = 4 + lokalny1;
       
        // argumentem może być skomplikowane wyrażenie...
        void funkcja(int a =kwadrat(globalny1), int);        //
       
        funkcja();                                                     //
       
    }                                      //
    cout << "---Jestesmy poza zakresem lokalnymn";
   
    funkcja();                                                           //
}
//************************************************************
void funkcja(int a, int b)
{
    cout << "Naprawde nastapilo wywolanie:  funkcja("
        << a << ", " << b << ");" << endl;
}


____________________________________________________________________________________


#include <iostream>
using namespace std ;

float                                                  //
     poczatek_x,           // poczatek ukladu wspólrzednych
     poczatek_y ,
     skala_x = 1 ,          // skale: pozioma i pionowa
     skala_y = 1 ;
/*******************************************************/
inline float  wspx(float wspolrzedna)               //
{
     return( (wspolrzedna -  poczatek_x) * skala_x) ;
}
/******************************************************/
inline float  wspy(float wspolrzedna)            //
{
     return( (wspolrzedna -  poczatek_y) * skala_y) ;
}
/******************************************************/
int main()
{
float      x1 = 100,           // przykladowy punkt
          y1 = 100 ;

     cout << "Mamy w punkt o wspolrzednych n" ;
     cout << " x = " << wspx(x1)                    //
          << " y = " << wspy(y1) << endl ;          //

     // zmieniamy poczatek ukladu wspólrzednych
     poczatek_x = 20 ;
     poczatek_y = -500 ;

     cout << "Gdy przesuniemy uklad wspolrzednych tak, n"
          << "ze poczatek znajdzie sie w punkcie n"
          << poczatek_x << ", " << poczatek_y
          << "nto nowe wspolrzedne punktu n"
          << "w takim ukladzie sa : "
          << " x = " << wspx(x1)                     //
          << " y = " << wspy(y1) << endl ;          //

     // zageszczamy skale na osi poziomej
     skala_x = 0.5 ;
     cout << "Gdy dodatkowo zmienimy skale pozioma tak, "
          << "ze skala_x = " <<     skala_x
          << "nto ten sam punkt ma teraz wspolrzedne : n"
          << " x = " << wspx(x1)                     //
          << " y = " << wspy(y1) << endl ;          //


}


____________________________________________________________________________________



#include <iostream>
using namespace std ;

int  sumator(int jeszcze_krokow, int suma_dotychczas);     // 
void dwojkowo(int liczba);                                          // 
void schodki(int ile, char znak);
//*************************************************************
int  main()
{
    cout << "Ile pierwszych liczb naturalnych "
                "chcesz posumowac?: ";
    int n = 0 ;
    cin >> n;                                                  // 

    cout << "nSuma pierwszych " << n
        << " liczb naturalnych to = "
        << sumator(n, 0)                                // 
        << endl;
    //----------------------------------------------------------
    // zupelnie inny przykład funkcji rekurencyjnej
    //----------------------------------------------------------
    int liczba = 241 ;

    cout << "n" << liczba << " to dwojkowo " ;
    dwojkowo(liczba);                                // 
    cout << endl ;
    liczba = 30942;
    cout << "n" << liczba << " to dwojkowo " ;
    dwojkowo(liczba);                   
    cout << endl ;
    return 0;
}
//*************************************************************
int sumator(int jeszcze_krokow, int suma_dotychczas)          // 
{
    int rezultat = 0 ;                                                    // 
   
    static int krok_rekurencji ;                                    // 
    krok_rekurencji++ ;                                                // 
   
    int to_pietro_nr = krok_rekurencji ;                        // 
    schodki(to_pietro_nr, '>');                          //

    cout << suma_dotychczas << "+ " << to_pietro_nr
            << " = "
            << (suma_dotychczas + to_pietro_nr)
            << endl;
    // właściwa operacja sumowania
    suma_dotychczas += to_pietro_nr;                     //

    // warunek zatrzymujący rekurencję ++++++++++++
    if(jeszcze_krokow > 0)                              //
    {
       // kontynujemy wywołania rekurencyjne
         rezultat =
           sumator(jeszcze_krokow -1, suma_dotychczas);        //
    }
    else
    {
       // zatrzymujemy
       cout << "........to ostatni krok, wracamy ......"
                << endl;
       rezultat = suma_dotychczas;                        //
    }
    //++++++++++++++++++++++++++++++++++++   

    schodki(to_pietro_nr, '<');                                //
    cout << endl;
    krok_rekurencji-- ;                                  //
    return rezultat ;                                         //
}
//************************************************************
void dwojkowo(int liczba)                                     //
{
    int reszta = liczba % 2 ;                                  //
    if(liczba > 1)                       // warunek zatrzymujący    
    {
        dwojkowo(liczba / 2) ;       // wywołanie rekurencyjne   
    }
    cout << reszta ;                                                  //
    return ;
}
//*************************************************************
void schodki(int ile, char znak)                              //
{
    cout << ile << " pietro: " ;
    for(int m = 0 ; m < ile ; m++)       
    {
        cout << znak << " " ;
    }
    cout << " " ;
}