Przykłady programów w C i C++

/* Skladnia programu w C */
/* Komentarze */
/* -- Komentarze - początek
 #include  <bibl.h>  - włączenie biblioteki, np. <stdio.h>, <conio.h>
 #define  NAZWA tekst  - definicja stałej symbolicznej, np. #define PI 3.145926
--koniec komentarzy
*/
 main()  /* klamra otwierająca - początek funkcji głównej
(jak begin w Pascalu)*/
 {   /* tu zaczyna się treść programu - w funkcji main()*/
  /* treść */         
 }    /* klamra zamykająca - jak end w Pascalu*/
/* - rozpoczęcie komentarza w C      - koniec komentarza*/
// komentarz w C++
-----------------------------------------------------------------------------------------

 

/* Zawartość pliku hello.c – wersja w języku C */
/* program hello.c */
#include <stdio.h>
int main (void)
{
printf ("Hello World!");
return 0;
}

-------------------------------------------------------------------------------------------------
//  Zawartość pliku hello.cpp – wersja w języku C++
//  hello.cpp 
#include <iostream.h>
// preprocessor - dołączenie biblioteki  systemowej do funkcji cout – input ootput stream
int main()
{
cout << "Hello World!"; // wyświetlenie napisu
return 0;
}

-------------------------------------------------------------------------------------------

/* Przyklady programow w C i C++ *
/* Program P1.C - w jezyku C */
# include <stdio.h>
/* Komentarze
 # - preprocesor - wstępny przetwarzacz - uwzględnia dodatkowe rzeczy
 #include <stdio.h> - dołączenie nagłówków z biblioteki standardowej (ścieżka domyślnych przeszukiwań)
 #include "program.h" - dołączenie programu z katalogu aktualnego - podwójne cudzysłowy
/*
main()
{
printf("Pierwszy program w C !");
return 0;
}

-------------------------------------------------------------------------------------
/* Program P1a.CPP - najprostszy program w C++ */
void main(void)
{
}

-------------------------------------------------------------------------------------
/* Program P1.CPP – w jezyku C++ */
// To tez komentarz ale w 1 linii
/* Taki komentarz moze byc w kilku wierszach
*/
# include <iostream.h> //
void main(void)
{
cout << "Pierwszy program w C++ !";
}

------------------------------------------------------------------------------------
/* Program p1.c */
#include <stdio.h>
void main(void)
{
printf("Nazwisko Imie: Pierwszy program w C");
}

-------------------------------------------------------------------------------------
/* P1a.c  - komentarze*/
/* Komentarz: Polecenie #include<plik.h> jest dyrektywa dla kompilatora
by wykorzystal informacje w pliku naglowkowym plik.h>
*/
# include <stdio.h> /* dolacz. stdio.h - standard wejscia/wyjscia */
# include <conio.h> /* dolacz bibl. conio.h do obslugi ekarnu */
main()  /* Poczatek funkcji glownej programu */
{
clrscr();  /* kasowanie ekranu - wykorzystuje conio.h */
printf("Pierwszy program w C") ; /* wysyla napis na stand. wyjscie */
getch(); /* Czekanie na nacisniecie znaku z konsoli */
return;
} /* Koniec funkcji glownej programu */
-------------------------------------------------------------------------------------

//* program p1a1.c  */
// to jest komentarz w jednej linii – używać powinno się tylko w C++
/* to jest też komentarz, może mieć kilka linii, dłuższy, ograniczony */
#include <stdio.h>  /* dołączenie pliku nagłówkowego z biblioteki systemowej
potrzebny do wywołania instrukcji printf   */
#include <conio.h>     /* dołączenie pliku conio.h do funkcji getch() i clrscr() */
int  main()       /* funkcja główna main() */
{  /*  początek main()*/
   clrscr();       /*  kasowanie ekranu */
   printf("Nazwisko Imie: Pierwszy program w C,  zmodyfikowany ");
   printf("\nNacisnij jakis klawisz  ");
   getch();         /*  czeka na jakiś klawisz */
   return 0;        /*  funkcja główna zwraca 0 przy pomyślnym wyniku zakończenia */
}          /*  koniec funkcji głównej main() */

--------------------------------------------------------------------------------------------

/* Program P1a.CPP  - program pierwszy w C++ */
# include <iostream.h> // dolaczenie pliku naglowkowego
# include <conio.h>
void main(void)
// void oznacza, ze funkcja nie zwraca wartosci do systemu operacyjnego
{
clrscr();
cout << "Pierwszy program w C++ !\n";
cout << "Napisz jakis znak i nacisnij Enter\n";
// \n - przejscie do nowej linii
getch();
}
-------------------------------------------------------------------------------------
* Program objw1.c  -  Obliczanie objętości walca   (startowy)      */

/*------------------------------------------------------*/

 

#include <stdio.h>

 

void main()

 

{

   float promien, wysokosc, objetosc;

 

   promien  = 3.3;

   wysokosc = 44.4;

   objetosc = 3.1415926 * promien * promien * wysokosc;

   printf("Objetosc walca = %f", objetosc);

}

/********************************************************/

 ----------------------------------------------------------------------------------------------------------

/* Program daneos1.c  - dane osobowe*/
#include <stdio.h>
int main(void)
/*
funkcja glowna, brak argumentow, zwraca typ calkowity int */
{
            char imie[20];  /* deklaracja tablicy znakow – łańcuch – tekst na 19 znaków
            int i;   /* deklaracja zmiennej całkowitej i
            printf("\nPodaj swoje imie ");  // wydruk napisu na ekran,\n – nowa linia
            gets(imie);   // wprowadzenie imienia
            puts("Ile masz lat? "); // wydruk napisu – funkcja puts()
            scanf("%d",&i);  // wprowadzenie lat
            printf("\n%s ma %d lat.",imie, i); // wyświetlenie imienia i lat
            return 0;   /* funkcja glowna zwraca 0 – pomyślny koniec */
}

/*  Uwaga! Po uruchomieniu Alt F5 – ekran wyników. 8?

-----------------------------------------------------------------------------------------

 * -------------- polepros1.c  - boki a i b w programie ------------- */
void main(void)
{
float a, b;    // deklarujemy zmienne przechowujące boki prostokąta
  float pole; // deklarujemy zmienną zawierającą wynik obliczeń
 
  a = 5; b =10;    // przypisujemy im wartości
  pole = a * b; // obliczamy pole prostokąta (tu równe 50)
  printf("Pole = %f",pole);
  getch();
}

-----------------------------------------------------------------------------------------
*  ----------------polepros2.c  - z funkcja  -------------------------/*
#include <stdio.h>

#include <conio.h>
 
float PoleProstokata(float bok1, float bok2)
{
  // w tym miejscu bok1 jest równy 5,
  // natomiast b jest równe 10
    float wynik;
    wynik = bok1 * bok2;
  return wynik;
}
 
void main(void)
{
  float a, b, p;
 
  a = 5; b = 10;
  p= PoleProstokata(a, b);
  printf("Pole prostokat o bokach %f i %f = %f ", a, b, p);
  getch();
}

--------------------------------------------------------------------------------
/* ppros3.c - z funkcja */
#include <stdio.h>
#include <conio.h>
 
 float PoleProstokata(float bok1, float bok2); /* zapowiedz funkcji */
 
/* funkcja glowna */
int main(void)
{
  float a, b, p;
  puts("Obliczenie pola prostokata o bokach a i b ");
  printf("Podaj a i b oddzielone spacja: ");
  scanf("%f %f",&a, &b);
  /* wywolanie funkcji na obliczenie pola */
  p= PoleProstokata(a, b);
  printf("Pole prostokat o bokach %f i %f = %f ", a, b, p);
  getch();
  return 0;
}
 
float PoleProstokata(float bok1, float bok2)
{
  // w tym miejscu bok1 jest równy a,
  // natomiast bok2 jest równy b
  float wynik;
  wynik = bok1 * bok2;
  return wynik;
}
 
-----------------------------------------------------------------------------------------
/* ppros4.c - z funkcja */
#include <stdio.h>
#include <conio.h>
 
float PoleProstokata(float bok1, float bok2); /* zapowiedz funkcji */
 
/* funckja glowna */
int main()
{
  float a, b, p;
  puts("Obliczenie pola prostokata o bokach a i b ");
  printf("Wprowadz a   ");
  scanf("%f", &a);  /* wprowadzenie a */
  printf("Wprowadz b   ");
  scanf("%f", &b); /* wprowadzenie b */
  p= PoleProstokata(a, b); /* wywolanie funkcji z parametrami a i b */
  printf("Pole prostokat o bokach %f i %f = %10.2f \n", a, b, p);
  printf("\nNacisnij cos ");
  getch(); /* czeka na znak */
  return 0;
}
 
/* Funkcja - definicja */
float PoleProstokata(float bok1, float bok2)
{
  /* w tym miejscu bok1 jest równy a,
   natomiast bok2 jest równy b */
  float wynik;
  wynik = bok1 * bok2;
  return wynik;
}
 
 
-----------------------------------------------------------------------------------------


/ Program czas.cpp w jezyku C++ - wyświetlenie czasu – komentarz w C++
#include <iostream.h>
  #include <time.h>
  main()
  {
   int a;
   time_t czas;
   do {
    cout << "1 - Wyswietl aktualny czas" << endl;
    cout << "2 - Zakoncz program" << endl;
    cout << "Twoj wybor?";
    cin >> a;
    if (a == 1)
    {
     time(&czas);
     cout << ctime(&czas);
    }
   }while (a != 2);
   cout << "Do zobaczenia" << endl;
  }

-----------------------------------------------------------------------------------------

/********************************************************/
/*  Program  objwalc.c                               */
/*  Obliczanie objetosci walca (rozroznianie nazwy /1)*/
/*------------------------------------------------------*/
 
#include <stdio.h>
 
main()
 
{
   float promien, wysokosc, objetosc;
   float PROMIEN, WYSOKOSC, OBJETOSC;
 
   promien  = 3.3;   PROMIEN  = 10.;
   wysokosc = 44.4;  WYSOKOSC = 20.;
 
   objetosc = 3.1415926 * promien * promien * wysokosc;
   printf("\nObjetosc walca = %f", objetosc);
 
   OBJETOSC = 3.1415926 * PROMIEN * PROMIEN * WYSOKOSC;
   printf("\nOBJETOSC WALCA = %f", OBJETOSC);
}

---------------------------------------------------------------
/********************************************************/
/* Przykład z walcem, z zastosowaniem pseudoinstrukcji #define */
/*******************************************************/
/*  Program  p8.c                                    */
/*  Obliczanie objetosci walca        ( #define )    */
/*------------------------------------------------------*/
#include <stdio.h>
#define PI        3.1415926
#define PROMIEN   3.3
#define WYSOKOSC 44.4
#define WYNIK    printf("Objetosc walca = %f", objetosc)
 
main()
{
   float promien, wysokosc, objetosc;
    promien  = PROMIEN;
   wysokosc = WYSOKOSC;
   objetosc = PI * promien * promien * wysokosc;
   WYNIK;
}
/********************************************************/
------------------------------------------------------------------------------------
********************************************************/
/*  Program  p9.c                                 */
/*  Obliczanie objetosci walca     ( zmienne )    */
/*------------------------------------------------------*/
 
#include <stdio.h>
 
#define PI        3.1415926
#define PROMIEN   3.3
#define WYNIK    printf("Objetosc walca = %f", objetosc)
 
main()
 
{
   float promien, wysokosc, objetosc;
   int i;
 
   promien  = PROMIEN;
   objetosc = PI * promien * promien * wysokosc;   /* uwaga */
   WYNIK;
   i=40000;                                   /* uwaga */
   printf("\ni = %i ", i);
}
/* Objętość walca jest równa 0, bo nie została zainicjalizowana zmienna 'wysokosc'
- przez domniemanie kompilator przyjął 0.
Na wydruku i widać, że nastąpiło przekroczenie dopuszczalnego zakresu zmiennej 'i' typu int.
*/
/********************************************************/
------------------------------------------------------------------------------------


/* Wersja programu  do  wczytania  2 liczb a i b typu całkowitego:
//Program kalk1a.c
// Wczytuje 2 liczby całkowite I wyświetla na ekranie
*/ #include <stdio.h>
#include <conio.h>
int main ()
{
        int a,b; //deklaracja zmiennych a i b
        clrscr();
        printf("Podaj liczbe a: ");
        scanf("%d",&a); // wczytanie liczby a
        printf("Podaj liczbe b: ");
        scanf("%d",&b);  // wczytanie liczby b
        printf("Wpisane liczby a i b : %d, %d.\n",a,b);
        printf("\nNacisnij Enter ");
        getch(); // czekanie na Enter
        return 0 ;
}


-------------------------------------------------------------------------------------
/* Program kalkulator, wykonujący podstawowe obliczenia matematyczne */
 /* Program kalk1.c */

#include <stdio.h>

#include <conio.h>

int main() /* funkcja glowna */

{

int a,b; /* deklaracja zmiennych całkowitych a i b */

int suma,roznica,iloczyn;

float iloraz; /* deklaracja zmiennej rzeczywistej */

clrscr();  /* kasowanie ekranu */

printf("Prosty kalkulator\n");

printf("\nPodaj liczbe a: ");

scanf("%d",&a);  /* wczytanie liczby a */

printf("Podaj liczbe b: ");

scanf("%d",&b); /* wczytanie liczby b */

/* obliczenia */

suma=a+b;

roznica=a-b;

iloczyn=a*b;

iloraz=(float)a/(float)b; /* operator rzutowania w dzieleniu */

/* Wydruk wynikow */

printf("\nWyniki dzialan:\n");

printf("\nSuma:    %d  ",suma);

printf("\nRoznica: %d  ",roznica);

printf("\nIloczyn: %d  ",iloczyn);

printf("\nIloraz:  %f  ",iloraz);

 

getch(); /* czeka na naciśniecie klawisza */

return 0 ;

}
--------------------------------------------------------------------------------------

/* Przykład operacji na słowach i łańcuchach: */
/* znaki1.c */
#include <stdio.h>
#include <conio.h>
#include <string.h>
main (void)
{
char znak1,znak2,znak3; //deklaracja znaków
char *slowo1; // *slowo2;
char slowo2[20];
clrscr();  // czyszczenie ekranu
znak1='a';
znak2=102; // znak w postaci kodu dziesiętnego ASCII – litera f
slowo1="Imie"; // wpisujemy własne imię
 
printf("Podaj znak3: "); scanf("%c",&znak3); // podajemy jakiś znak
 
printf("\nPodaj slowo2: "); scanf("%s",slowo2); // wpisujemy słowo
 
printf("\nZmienne zawieraja znaki: ");
printf("znak1 (a), znak2 (102), znak3 (wprowadzony): %c %c %c  ",znak1,znak2,znak3);
printf("\noraz slowa: ");
printf("slowo1, slowo2: %s %s  ",slowo1, slowo2);
 
getch();
return 0 ;
}

------------------------------------------------------------------------------------------

/* Program, który podaje kod wciśniętego przez nas klawisza:  */
#include <stdio.h>
#include <conio.h>
#include <string.h>
main (void)
{
char znak;
int kod;
clrscr();
 
printf("Wciśnij znak na klawiaturze: \n");
scanf("%c",&znak);
printf("Kod wciśniętego znaku to: %d \n",znak);
 
printf("Podaj kod znaku: \n");
scanf("%d",&kod);
printf("Znak o podanym kodzie to: %c \n",kod);
 
getch();
return 0 ;
}
---------------------------------------------------------------------------
/* Do odczytania długości łańcucha służy funkcja strlen(). */
#include <stdio.h>
#include <conio.h>
#include <string.h>
main (void)
{
int dlugosc;
char *lancuch;
clrscr();
 
lancuch="Adam Nowak";
dlugosc=strlen(lancuch);
printf("Lancuch '%s' ma: %d znaków \n",lancuch, dlugosc);
 
printf("Pierwsza litera łańcucha to: %c \n",lancuch[0]);
printf("Ostatnia litera łańcucha to: %c \n",lancuch[dlugosc-1]);
 
getch();
return 0 ;
}

---------------------------------------------------------------------------
/********************************************************/
/*  Program  p12.c                                    */
/*                            ( putchar )            */
/*------------------------------------------------------*/
#include <stdio.h>
#define SPACJA 32
 
main()
{
  char napis[] = "ABCDEFGHIJKLMNOPQRS...";
  int znak = 73;
  /* wyprowadzanie pojedynczych znakow
     przy pomocy funkcji  putchar   */
  putchar('\n');     putchar(znak);     putchar(SPACJA);
  putchar(55);       putchar(SPACJA);   putchar('Z');
  putchar(SPACJA);   putchar('\066');   putchar(SPACJA);
  putchar('\x3A');   putchar('\n');     putchar(napis[0]);
  putchar(SPACJA);   putchar(napis[4]); putchar(SPACJA);
  putchar(znak+'\066'-52);              putchar('\n');
}
/********************************************************/

-----------------------------------------------------------------------------
/********************************************************/
/* Program  p14.c  wydruk liczby w 3 systemach: 10, 8, 16 */
/*                            ( printf  /1/ )        */
/*------------------------------------------------------*/
 
#include <stdio.h>
 
main()
{
  int  k = 21101;  /* liczba dziesietna */
  printf("\nk(_10) = %i   k(_8) = %o    k(_16) = %X", k, k, k);
  
}
/********************************************************/

---------------------------------------------------------------------------
/********************************************************/
/*  Program  p15.c                                   */
/*                            ( printf  /2/ )        */
/*------------------------------------------------------*/
#include <stdio.h>
 
main()
{
  float  a,b,c;
      a=153.67789;    b=2.33E-2;   c = a * b;
      printf(" %f  razy  %E  wynosi:  %f ", a,b,c);
}
/********************************************************/

------------------------------------------------------------------------------
/********************************************************/
/*  Program  p17.c             ( Turbo C 2.0 )        */
/*                             ( printf  /4/ )        */
/*------------------------------------------------------*/
 
#include <stdio.h>
 
main()  /* zagadnienie dokladnosci */
{
  double  a=153.67789;
  int     k=22799;
  int     m=-500;
  int     *p;     /* wskaznik */
  char    c='M';
  char    napis[]="Lepsze C od B lub P    ";
 
  p=&k;
  printf("\n format  %%d   %d", k);
  printf("\n format  %%i   %i", m);
  printf("\n format  %%u   %u", k);
  printf("\n format  %%o   %o", k);
  printf("\n format  %%x   %x", k);
  printf("\n format  %%X   %X", k);
  printf("\n format  %%f   %f", a);
  printf("\n format  %%e   %e", a);
  printf("\n format  %%E   %E", a);
  printf("\n format  %%g   %g", a);
  printf("\n format  %%G   %G", a);
  printf("\n format  %%c   %c", c);
  printf("\n format  %%s   %s", napis);
  printf("\n format  %%p   %p", *p);
  printf("\n ------------------------");
  printf("\n "); printf(napis);
}
/********************************************************/

---------------------------------------------------------------------------
/* zapis1.c  - zapis liczb w roznych systemach */
#include <stdio.h>

 
void main(void)
{
  float        f = 0.521;
  int          i = -123;
  unsigned int u = 24;
  char         c = 'A';
 
  printf("Zmienna f = %f, a zmienna i jest rowna %d.\n", f, i);
  printf("Zmienna c = %c, a zmienna u jest rowna %u.\n", c, u);
  printf("Zmienna u w zapisie szesnastkowym jest rowna %x, \n", u);
  printf("natomiast w zapisie osemkowym jest rowna %o.", u);
}

------------------------------------------------------------------------------
********************************************************/
/*  Program  p21.c                                   */
/*  Obliczanie objetosci walca   ( wieksza dokladnosc ) */
/*------------------------------------------------------*/
 
#include <stdio.h>
 
#define PI           3.1415926
#define PROMIEN      3.3
#define WYSOKOSC    44.4
 
main()
{
   double promien, wysokosc, objetosc;
 
   promien  = PROMIEN;
   wysokosc = WYSOKOSC;
   objetosc = PI * promien * promien * wysokosc;
   printf("\nObjetosc walca = %f", objetosc);
   printf("\nObjetosc walca = %E", objetosc);
   printf("\nObjetosc walca = %g", objetosc);
   printf("\nObjetosc walca = %15.10f", objetosc);
   printf("\nObjetosc walca = %25.20f", objetosc);
 
}
---------------------------------------------------------------------------
/* getchar1.c */
#include <stdio.h>

 
/* przepisz wejscie na wyjście, wersja 1 */
main()
{
int c;
c = getchar(); /* przeczytaj znak */
 
while (c != EOF) /* dopóki znak nie jest znakiem konca pliku (Ctrl Z) */
  {
        putchar(c);  /* wypisz przeczytany znak */
        c=getchar(); /* przeczytaj nastepny znak */
  }
}

---------------------------------------------------------------------------

/* Przykład programu do wydania reszty - ilość banknotów 20-, 10-, 5- i 1- dolarowych. */

/* change.c */
#include <stdio.h>
main()
{
int amount,twenties, tens, fives, ones, r20, r10;
printf("Wprowadz kwote do wydania: "); /* Wprowadzenie kwoty do wydania */
scanf("%d", &amount);
twenties= amount/20; /* banknoty 20-dolarowe */
r20=amount % 20;  /* r20 reszta pozostała po 20-ch*/
tens= r20/10; /* ilość banknotów 10-dolarowych */
r10=r20 % 10;  /* r10 reprezentuje resztę po 10-ch */
fives= r10 / 5; /* banknoty 5-dolarowe */
ones = r10 % 5; /* reszta - dolarówki */
putchar('\n');
printf("By przekazac %d wydaj banknoty: \n", amount);
printf("%d dwudziestki\n", twenties);
printf("%d dziesiatki\n", tens);
printf("%d piatki \n", fives);
printf("%d pojedyncze (s)\n", ones);
}

-----------------------------------------------------------------------------
/* intfloat.c */
/* wyswietlanie liczb */
#include <stdio.h>

void main()
{
 int t;
 float c, s, r;
 c=56.09;
 s=4.98;
 t=c+s; // calkowite
 r=c+s; // rzeczywiste
 printf ("Razem - (int): %d  (float): %.2f",t, r);

----------------------------------------------------------------------------
/* Przykład program z zastosowaniem operatorów unarnych */
/********************************************************/
/*  Program  p33.c                                    */
/*                          ( operatory unarne )     */
/*------------------------------------------------------*/
 
#include <stdio.h>
 
main()
{
  int   i=5 ;
 
  printf("\n----------------");
  printf("\n  i = %i ",   i  );
  printf("\n  i = %i ", ++i  );
  printf("\n  i = %i ",   i  );
  printf("\n  i = %i ",   i++);
  printf("\n  i = %i ",   i  );
  printf("\n  i = %i ", --i  );
  printf("\n  i = %i ",   i  );
  printf("\n  i = %i ",   i--);
  printf("\n  i = %i ",   i  );
  printf("\n  i = %i ",  -i  );
  printf("\n----------------");
}

---------------------------------------------------------------
/* Przykład programu z operatorami konwersji: */
/********************************************************/
/*  Program p35.c                                    */
/*                        ( operator konwersji )     */
/*------------------------------------------------------*/
 
#include <stdio.h>
#include <math.h>
 
main()
{
   char                 c = 'k';
   int                  i = 70;
   float                f = 345.6789;
 
   printf("\n Wartosci poczatkowe:  ");
   printf("\n c = \'%c\';  i = %i;  f = %8.4f;", c ,i, f);
   printf("\n-------------------------------------");
   printf("\n Konwersja           Wynik           ");
   printf("\n-------------------------------------");
   printf("\n (int)    c          %i ", (int)    c      );
   printf("\n (float)  c          %f ", (float)  c      );
   printf("\n (double) i          %f ", (double) i      );
   printf("\n (char)   i          %c ", (char)   i      );
   printf("\n (double) i+2000     %f ", (double) i+2000 );
   printf("\n (int)    f          %i ", (int)    f      );
   printf("\n sqrt((double) c)    %f ", sqrt((double) c));
   printf("\n-------------------------------------");
}
/********************************************************/
----------------------------------------------------------------

/* sizeof.c */
include <stdio.h>

 
int main()
{
 printf("sizeof(short ) = %d\n", sizeof(short ));
 printf("sizeof(int   ) = %d\n", sizeof(int   ));
 printf("sizeof(long  ) = %d\n", sizeof(long  ));
 printf("sizeof(float ) = %d\n", sizeof(float ));
 printf("sizeof(double) = %d\n", sizeof(double));
 return 0;
}

---------------------------------------------------------------------------------
/* Typowe zastosowanie - funkcja max */
/ / Program operwar.cpp
/* C++ - Operator warunkowy - funkacja max */
#include <iostream.h>
void main()
{
 int max(int, int);
 int a, b, m;
 char c;
 cout << "Program wyznacza max 2 liczb\n";
 cout << "Podaj 2 liczby calkowite oddzielone spacja: ";
 cin >> a >> b;
 m=max(a,b);
 cout << "Max liczb " << a << " i " << b << " wynosi " << m;
 cout << "\nNacisnij cos";
 cin >> c;
}
int max(int i, int j)
{
 return i > j? i: j;
}

===============================================
/*  if1a.c – instrukcja if  */
#include <stdio.h>
#include <conio.h>
#include <math.h>
main (void)
{
float liczba1, x;
clrscr();
x=0;
printf("Podaj liczbe dodatnia: \n");
scanf("%f",&liczba1);
 
if (liczba1 >=0)
 x=sqrt(liczba1);
printf("Pierwiastek z %f = %f", liczba1, x);
 
getch();
return 0 ;
}

----------------------------------------------------------------------
/*  program if1.c  */
#include <stdio.h>
#include <conio.h>
main (void)
{
int liczba1,liczba2;
clrscr();
 
printf("Podaj pierwszą liczbę: \n");
scanf("%d",&liczba1);
 
printf("Podaj drugą liczbę: \n");
scanf("%d",&liczba2);
 
if (liczba2==0)
printf("Nie wolno dzielić przez 0!\n");
else
printf("Wynik dzielenia: %f\n", (float) liczba1/liczba2);
 
getch();
return 0 ;
}

---------------------------------------------------------------------

// program if1.cpp

#include <iostream.h>

int Latka;

int main() {

 cout << "Program dla doroslych\nIle ty masz lat?\n";

 cin >> Latka;

 if (Latka < 18) cout << "Spadaj, malolacie!\n";

 else cout << "Ty stary koniu! ;>\n";

}

 -----------------------------------------------------------------

/* rownkwad. c*/
#include <stdio.h>

#include <conio.h>
main (void)
{
float A,B,C,delta;
clrscr();
 
printf("Podaj współczynnik A: \n");
scanf("%f",&A);
printf("Podaj współczynnik B: \n");
scanf("%f",&B);
printf("Podaj współczynnik C: \n");
scanf("%f",&C);
 
delta=b*b-4*a*c;
 
if (delta<0)
printf("Nie istnieją pierwiaski rzeczywiste!\n");
else
if (delta==0)
printf("Istnieje jeden pierwiastek rzeczywisty.\n");
else
printf("Istnieją dwa pierwiaski rzeczywiste.\n");
 
getch();
return 0 ;
}
--------------------------------------------------------------------

/* case1.c */#include <iostream>
 
int main()
{
  int liczba;
  cout << "Podaj liczbe: ";
  cin >> liczba;
  cout << endl;
 
  switch(liczba)
  {
    case 2: cout << "Dwa"; break; // opuszczenie switch - case
    case 4: cout << "Cztery"; break;
    case 8: cout << "Osiem"; break;
    default: cout << "Iles tam :)";
  }
}

-----------------------------------------------------------

/* case2.c */
#include <stdio.h>
#include <conio.h>
main (void)
{
char znak;
clrscr();
 
printf("Wciśnij cyfrę od 0 do 5\n");
scanf("%c",&znak);
switch(znak)
{
case '0': pritntf("nacisnąłeś klawisz 0");break; //przerwanie switch
case '1': pritntf("nacisnąłeś klawisz 1");break;
case '2': pritntf("nacisnąłeś klawisz 2");break;
case '3': pritntf("nacisnąłeś klawisz 3");break;
case '4': pritntf("nacisnąłeś klawisz 4");break;
case '5': pritntf("nacisnąłeś klawisz 5");break;
default: pritntf("nacisnąłeś jakiś inny klawisz"); // pozostałe przypadki
}
 
getch();
return 0 ;
} 
 
--------------------------------------------------------------------------
* program dowhile1.c */

include <stdio.h>

#include <conio.h>

 

void main(void)

{

  int licznik = 10;

 

  printf("Poczatek petli\n");

 

do

  {

    printf("Zmienna licznik = %d\n", licznik);

    licznik--;

  } while(licznik  != 0);

 

  printf("Koniec petli\n");

 getch();

}

--------------------------------------------------------------

/*  while1.c  Obliczenie sumy i iloczynu ciągu liczb zakończonych liczbą zero. */
#include <iostream.h>
 
void main(void)
{
 int s, i, l, n; // suma, iloczyn ciagu liczb, liczba w ciagu
 
 s=0;
 i=1;
 n=0;
 
 cout << "Podaj liczby (zero kończy)\n ";
 cin >> l;
 
 while ( l!= 0) // while (l)
 {
  s += l;
  i *= l;
  n++;
  cin >> l;
 }
 
 cout << "Ilosc liczb: " << n << "\n";
 cout << "Suma liczb wynosi " << s << endl;
 cout << "Iloczyn liczb = " << i;
}
---------------------------------------------------------------

/* while2.c */

#include <stdio.h>

#include <conio.h>

 

void main(void)

{

  int licznik = 10;

 

  printf("Poczatek petli\n");

 

  while(licznik  != 0)

  {

    printf("Zmienna licznik = %d\n", licznik);

    licznik--;

  }

  printf("Koniec petli\n");

 getch();

 

}

 

---------------------------------------------------------------------

// for1.cpp program drukowania 5 liczb
#include <iostream.h>
 
const int N=6;
void main(void)
{
for (int i=1; i<N; i++)
  cout << i << endl;
}

--------------------------------------------------------------

/* Tabliczka mnozenia */
/* timestab.c */
main()
{
int row, column;
          puts("\t\tMy Handy Multiplication Table\n\n");
     for(row=1; row <=10;row++)
          {
                                      for(column=1; column<=10;column++)
                                      printf("%6d", row*column);
          putchar('\n');
          }
}

 -----------------------------------------------------------





-------------------------------------------------------------------

/* P2.C  - puts(), gotoxy(), getch()*/
#include <stdio.h>
#include <conio.h> /* potrzebne do uzycia funkcji clrscr(); i getch(); */
int main()
{
clrscr(); /* Kasowanie ekranu */
gotoxy(1,1);
puts("Napis 1");
gotoxy(40, 12); /* 40 kol., 12 wiersz */
puts("Napis2");
gotoxy(30,20);
puts("Napis3");
puts("Tekst1 od poczatku nowego wiersza.");
puts("Tekst2 od poczatku wiersza. Puts przenosi kurosr do nowej linii");
getch(); /* Czeka na nacisniecie znaku */
return 0; /* Zwraca 0 do systemu operac. */
}
-------------------------------------------------------------------------------------
// P3.c  funkcje: gotoxy(x,y); oraz puts("napis");
/* funkcje: gotoxy(x,y); gdzie x kolumna (odl. od lewej,  y wiersz (old. z gory)
oraz puts("napis");
*/
#include <stdio.h>
#include <conio.h>
int main()
{
clrscr();
gotoxy(5, 3);
puts("X <- X=5 (od lewej), Y | (od gory) Y=3");
gotoxy(12, 8);
puts("X=12, Y=8");
gotoxy(32, 18);
puts(" X=32, Y=18");
getch();
return 0;
}
-------------------------------------------------------------------------------------
/* P4.C – kolor tla napisu i napisu */
#include <stdio.h>
#include <conio.h>
int main()
{
clrscr();
textbackground(WHITE);
textcolor(RED);
gotoxy(5, 3);
cprintf("X <- X=5, Y=3");
textbackground(YELLOW);
textcolor(BLUE);
gotoxy(6, 4);
cprintf("X <- X=6, Y=4");
textbackground(GREEN);
textcolor(BLACK);
gotoxy(7, 5);
cprintf("X <- X=7, Y=5");
getch();
return 0;
}
-------------------------------------------------------
/* P5.C */
#include <stdio.h>
#include <conio.h>
void main()
{
int kolor1 = BLACK;
int kolor2 = RED;
clrscr();
gotoxy(30, 1);
puts("STOP - [Fn] - klawisz funkcyjny\n");
do {
textbackground(kolor1++);
textcolor(kolor2);
cprintf("O");
getch();
} while (!kbhit());
clrscr();
}
-------------------------------------------------------
/* P6.C Wprowadzenie danych: funkcja scanf() oraz wydruk: printf() */
# include <conio.h>
# include <stdio.h>
void main()
{
float x, y; /* liczby rzeczywiste */
float wynik;
clrscr();
printf("Zamiana ulamka zwyklego na dziesietny\n");
printf("\nPodaj licznik ulamka: ");
scanf("%f", &x);
printf("\nPodaj mianownik ulamka: ");
scanf( "%f", &y);
wynik = x / y;
printf("\n %.0f : %0.f = %f \n", x, y, wynik);
printf("\n\n nacisnij dowolny klawisz...\n");
getch();
}
-------------------------------------------------------
/* P7.C Znaki specjalne, #define, puts(), putchar() */
# include <conio.h>
# include <stdio.h>
#define BELL '\007'
#define KIER '\003'
#define BUZIA '\001'
void main()
{
char litera;
clrscr();
litera = '\001';
puts("Znak osemk '005' \005");
puts("Kier1 '003' \003");
printf("Kier2 '003' "); putchar(KIER);
puts(""); /* nowa linia */
puts("Karo '004' \004");
puts("Trefl '005' \005");
puts("Pik '005' \006");
puts("Alfa '340' \340");
putchar(BELL); /* Dzwonek */
putchar('\007');
putchar(litera);
putchar(BUZIA);
printf("\n\nNacisnij dowolny klawisz...\n");
getch();
}
-------------------------------------------------------
/* Zam10_16.C Zamiana liczby 10-nej na 16-wa */
#include <stdio.h>
#include <conio.h>
int liczba;
int main()
{
clrscr();
printf("Podaj liczbe dziesietna calkowita ? \n");
scanf("%d", &liczba);
printf("\nSzesnastkowo: ");
printf("%x", liczba);
getch();
return 0;
}
-------------------------------------------------------
/* GETS.C  Funkcje gets(), scanf(), printf() */
#include <stdio.h>
#include <dos.h>
#include <math.h>
#include <string.h>
#include <conio.h>
#define MAX1 25
#define MAX2 30
void main()
{
char imie[MAX1], nazwisko[MAX2];
int wiek;
clrscr();
printf("Podaj swoje imie: ");
gets(imie);
printf("Podaj swoje nazwisko: ");
gets(nazwisko);
printf("Podaj swoj wiek: ");
scanf("%d", &wiek);
printf("Imie: %s \n", imie);
printf("Nazwisko: %s \n", nazwisko);
printf("Wiek: %d \n",wiek);
printf("Nazywasz sie: %s %s. Masz %d lat. ", imie, nazwisko, wiek);
getch();
}
-------------------------------------------------------
/* Wprowadz1.c   */
/* Funkcje getchar(), putchar(), puts() */
#include <conio.h>
#include <stdio.h>
void main()
{
char name[10], letter;
int index;
int initial;
index=0;
clrscr();
puts("Podaj 1 litere imienia: ");
initial = getchar();
putchar('\n');
putchar(initial);
putchar('\n');
printf("\n Twoj inicjal: %c \n",initial);
getch();
puts("\nPodaj imie, nacisnij Enter");
do
{
letter=getchar();
name[index]=letter;
index++;
}
while(letter !='\r' && index<9);
name[index]='\0';
putchar('\n');
puts(name);
getch();
}
-------------------------------------------------------
// Fahr1.c - przeliczenie temperatur
/* zestawienie temper. Fahrenheita-Celsjusza dla f=0,20,..,300
wg B.W> Kernighana i D.M. Ritchiego */
#include <stdio.h>
#include <conio.h>
main()
{
int fahr,celsius;
int dolny, gorny,krok;
dolny=0; /* dolna granica trmper */
gorny=300; /* gorna granica */
krok=20; /* rozmiar kroku */
clrscr();
puts("Temperatury Fahrenheita i Celsjusza\n");
puts("C=5*(F-32)/9\n");
puts("st F | st C \n");
puts("---------------");
fahr=dolny;
while (fahr<=gorny)
{
celsius=5*(fahr-32)/9;
printf("%d\t%d\n",fahr,celsius);
fahr=fahr+krok;
}
getch();
return 0;
}
-------------------------------------------------------
// fahr2.c
/* zestawienie temper. Fahrenheita-Celsjusza
dla f=0,20,..,300, wersja zmiennopozycyjna
wg B.W> Kernighana i D.M. Ritchiego */
#include <stdio.h>
main()
{
float fahr,celsius;
int dolny, gorny,krok;
dolny=0; /* dolna granica trmper */
gorny=300; /* gorna granica */
krok=20; /* rozmiar kroku */
fahr=dolny;
while (fahr<=gorny)
{
celsius=5.0/9.0*(fahr-32);
printf("%3.0f %6.1f\n",fahr,celsius);
fahr=fahr+krok;
}
return 0;
}
-------------------------------------------------------
// fahr3.c
/* zestawienie temper. Fahrenheita-Celsjusza
dla f=0,20,..,300, wersja z petla for
wg B.W> Kernighana i D.M. Ritchiego */
#include <stdio.h>
main()
{
int fahr;
for (fahr=0; fahr<=300; fahr=fahr+20)
printf("%3d %6.1f\n",
fahr,(5.0/9.0)*(fahr-32));
return 0;
}
/* zestawienie temper. Fahrenheita-Celsjusza
dla f=0,20,..,300, wersja z petla for
wg B.W> Kernighana i D.M. Ritchiego */
#include <stdio.h>
main()
{
int fahr;
for (fahr=0; fahr<=300; fahr=fahr+20)
printf("%3d %6.1f\n",
fahr,(5.0/9.0)*(fahr-32));
return 0;
}
-------------------------------------------------------
/*  rowkw1.c  - program rozwiazywania rownania kwadratowego */
#include <stdio.h>
#include <math.h>
#include <conio.h>
main()
{
float a,b,c,d,x1,x2;
clrscr();
printf("Podaj wspolczynniki rownania ax^2+bx+c\n");
printf("a b c: ");
scanf("%f%f%f",&a,&b,&c);
if(a==0)
printf("bledne dane\n");
else
{
d=b*b-4*a*c;
if(d<0)
printf("brak pierwiastkow "
"rzeczywistych\n");
else if(d==0)
{
x1=-b/(2*a);
printf("x1=%f\n",x1);
}
else
{
x1=(-b-sqrt(d))/(2*a);
x2=(-b+sqrt(d))/(2*a);
printf("x1=%f x2=%f\n",x1,x2);
}
}
getch();
clrscr();
return 0;
}
-------------------------------------------------------
/* srarytm.c  - srednia arytmet */
#include <stdio.h>
#include <conio.h>
main()
{
int n;
double suma;
float liczba;
clrscr();
printf("Srednia wprowadzonych liczb\n");
printf("Wprowadz kolejne liczby, Ctrl Z lub F6 - koniec\n");;
for(n=0, suma=0;
scanf("%f",&liczba)==1;
suma += liczba, n++)
;
if(n==0)
printf("ciag pusty\n");
else
printf("liczba elementow = %5d "
" srednia = %lf\n",n,suma/n);
getch();
return 0;
}
-------------------------------------------------------
/* zamlit.c  -  zamiana liter */
#include <stdio.h>
#include <ctype.h>
#include <conio.h>
main()
{
int c,d ;
clrscr();
puts("Zamiana malych liter na duze");
puts("Wprowadz ciag malych liter, ^Z - koniec");
while ( (c=getchar()) != EOF )
putchar(toupper(c)) ;
puts("Zamiana DUZYCH liter na male");
puts("Wprowadz ciag duzych liter, ^Z - koniec");
while ( (c=getchar()) != EOF )
putchar(tolower(c)) ;
getch();
return 0;
}
-------------------------------------------------------
/* zamlanc. c    Zamiana lancucha znakow */
#include <string.h>
#include <stdio.h>
#include <ctype.h>
#include <conio.h>
int main(void)
{
int length, length1, i;
char *string = "TO JEST LANCUCH ZNAKOW (NAPIS)";
char *string1 = "to jest lancuch drugi";
clrscr();
puts("1) Zamiana lancucha");
puts("TO JEST LANCUCH ZNAKOW (NAPIS)");
puts("na male litery\n");
length = strlen(string);
for (i=0; i<length; i++)
{
string[i] = tolower(string[i]);
}
printf("%s\n",string);
puts("--------------------------------------");
puts("\n2) Zamiana lancucha");
puts("to jest lancuch drugi");
puts("na duze litery\n");
length1 = strlen(string1);
for (i=0; i<length1; i++)
{
string1[i] = toupper(string1[i]);
}
printf("%s\n",string1);
getch();
return 0;
}
-------------------------------------------------------
/* zlicz.c  Program zlicza znaki, slowa i linie tekstu */
#include <stdio.h>
#include <conio.h>
#define IN 1 /* wewn. slowa */
#define OUT 0 /* zewn. slowa */
/* zlicz wejsciowe wiersze, slowa, znaki */
main()
{
int c, nl, nw, nc, state, nn;
state=OUT;
nl=nw=nc=nn=0;
/* nl - ilosc linii
nw - ilosc slow
nc - ilosc znakow
*/
clrscr();
puts("Program zlicza znaki, slowa i linie tekstu");
puts("Wprowadz tekst, ^Z - koniec\n");
while ((c=getchar()) != EOF)
{
++nc;
if (c=='\n')
{
++nl;
{ printf("\n");}
}
if (c==' ' || c=='\n' || c=='\t')
{
++nn;
state=OUT;
if ((nn==1) && (state==OUT)) printf("\n");
}
else
{
putchar(c);
if (state==OUT)
{
state=IN;
++nw;
nn=0;
}
}
}
printf("Ilosc linii: %d Ilosc slow: %d Ilosc znakow: %d\n",nl,nw,nc);
getch();
return 0;
}
-------------------------------------------------------
/* Progzl1.c   zliczanie znakow, slow, wierszy */
#include <stdio.h>
void main()
{
int z, ilz, ils, ilw, i;
ilz=ils=ilw=0;
for (i=1; i<=24; i++) printf("\n");
printf("Program zlicza znaki, slowa, linie\n");
printf("Pisz znaki, Ctrl Z (lub Ctrl Y) - koniec\n");
while ((z=getchar()) != EOF)
{
putchar(z);
/* ilz=ilz+1; */
ilz++;
if (( (z==' ') || (z=='\n') ) && (ilz>0)) ils=ils+1;
if (z=='\n') ilw=ilw+1;
}
printf("Ilosc znakow %d\n",ilz);
printf("Ilosc slow %d\n",ils);
printf("Ilosc wierszy %d\n",ilw);
printf("Nacisnij Enter ");
z=getchar();
}
-------------------------------------------------------
/* zamliczb.c  Zamiana liczb na 10-nych na system 2-wy, 16-wy, 8-wy */
#include <STDIO.H>
#include <STDLIB.H>
#include <conio.h>
void main()
{ char Bufor[33];
unsigned long Liczba;
clrscr();
puts("Zamiana liczby w systemie 10 na inne systemy\n");
Liczba = 1;
while (Liczba != 0)
{
printf("Podaj liczbe calkowita (0 - koniec): ");
scanf("%D", &Liczba);
ultoa(Liczba, Bufor, 2);
printf("Dwojkowo : %s\n", Bufor);
ultoa(Liczba, Bufor, 16);
printf("Szestnastkowo: %s\n", Bufor);
ultoa(Liczba, Bufor, 8);
printf("Osemkowo : %s\n", Bufor);
}
getch();
}
-------------------------------------------------------
/* Program zg1.c – Komputer zgaduje wymyslona przez uzytkown. liczbe */
#include <stdio.h>
#include <conio.h>
#include <ctype.h>
#define p 1
#define k 1000
int x, xm, xd, krok, tak;
char o;
void main (void)
{
clrscr();
tak=0;
x=(p+k)/ 2;
xm=p;
xd=k;
krok=0;
printf("Program ZG1.CPP\n");
printf("\nProgram zgaduje wymyslona przez Ciebie liczbe calkowita z zakresu 1..1000");
printf("\n\nWyswietla kolejno proponowane wartosci, odpowiedz: ");
printf("\nczy liczba za duza - d, za mala - m, czy tez wlasciwa - w");
printf("\n\n");
printf("\nNacisnij cos .. ");
o=getche();
clrscr();
while (tak != 1)
{
krok=krok+1;
printf("\nProponowana liczba %i ",x);
printf("\nOdpowiedz: d-liczba za duza, m-za mala, w-wlasciwa (d/m/w): ");
o=' ';
do
{
o=getchar();
o=tolower(o);
}
while ((o != 'd') && (o != 'm') && (o != 'w'));
if (o == 'w')
{
tak=1;
printf("\nDobra! x= %i ",x);
}
else /* odp <> 'w' */
{
if (o=='d')
{
printf("\nOdpowiedziales ze za duza\n");
xd=x;
x=(xm + xd) / 2;
} /* 'd' */
else /* 'm' */
{
printf("\nOdpowiedziales, ze za mala\n");
xm=x;
x=((xm+xd)/2) +1;
}; /* 'm' */
}; /* odp <> 'w' */
}; /* while */
printf("\nZgadlem po %i krokach\n ",krok);
printf("\nNacisnij cos ");
o=getche();
clrscr();
} /* main */
==================================================================================
/* FUNKCJE */
==================================================================================
/* quiz1.c - Wywolanie funkcji answer() */
#include <stdio.h>
#include <conio.h>
main()
{
int pauza;
clrscr();
puts("Ile bajtow ma 1KB?\n");
puts("Nacisnij Enter to sie dowiesz\n");
pauza=getchar();
/* Realicacja funkcji answer() */
answer();
getch();
clrscr();
return(0);
} /* main */
answer() /* Funkcja */
{
puts("1 KB ma 1024 B.");
/* Powrot do main() */
return;
} /* Funkcja */
------------------------------------------------------------------------------------
/* quiz2.c Funkcje */
#include <stdio.h>
#include <conio.h>
int answer();
int question();
main()
{
clrscr();
puts("Witamy w turnieju\n");
question(); /* Wywolanie funkcji question() */
puts("Dzieki za udzial.\n");
getch();
return(0);
}
int question()
{
int move_on;
puts("Nazwa graf. interfejsu firmy z Microsoftu.\n");
puts("Enter - bedzie odpowiedz\n");
getch();
answer(); /* Funkcja question() wywoluje funkcje answer() */
return;
}
int answer()
{
puts("To Windows.\n");
return;
}
------------------------------------------------------------------------------------
/* quiz3.c Kilka funkcji - wywoluje funkcja main() */
#include <stdio.h>
#include <conio.h>
int welcome(); /* Prototyp funkcji */
int question();
int answer();
int the_end();
int main()
{
clrscr();
puts("1. Program glowny: main()");
welcome();
question();
answer();
the_end();
puts("2. Program glowny: main()");
getch();
return(0);
} /* Koniec main() */
/* Funkcje - definicje */
welcome()
{
puts("Funkcja welcome()");
puts("Witamy\n");
return (0);
}
int question()
{
puts("Funkcja question()");
puts("Glowny produkt Microsoft? \n");
return;
}
int answer()
{
puts("Funkcja answer()");
puts("Windows.\n");
return 0;
}
int the_end()
{
puts("Funkcja the_end()");
puts("Dziekuje.");
return 0;
}
/* Koniec lostingu quiz3.c */
------------------------------------------------------------------------------------
/* f_to_c.c Zamiana st Fahr. na Celsusza
Program ze zmienna zewn. temp. Funkcje
*/
#include <stdio.h>
#include <conio.h>
int temp; /* zmienna zewn */
main()
{
clrscr();
printf("Wprowadz temperature w st [F] :");
scanf("%d", &temp);
convert();
freeze();
boil();
getch();
}
convert()
{
float celsius;
celsius = (5.0/9.0)*(temp-32);
printf("%d st F to %6.2f st C\n",temp, celsius);
return;
}
freeze()
{
printf("To %d st od pktu zamarz. wody\n",temp-32);
return;
}
boil()
{
printf("To %d st od pktu wrzenia wody.\n", 212-temp);
return;
}
/* ------------ Koniec listingu f_to_c.c --- */
------------------------------------------------------------------------------------
/* stat.c - zmienna statyczna */
#include <stdio.h>
#include <dos.h>
#include <math.h>
#include <string.h>
#include <conio.h>
void doit(); /* prototyp funkcji */
void main()
{
clrscr();
puts("Funkcja doit() zawiera zmienna zwykla i statyczna - zwiekszane o 1 \n");
puts("1-e wywolanie funkcji doit()");
doit();
puts("\n2-e wywolanie funkcji doit()");
doit();
puts("\n3-e wywolanie funkcji doit()");
doit();
puts("\n4-e wywolanie funkcji doit()");
doit();
getch();
} /* main() */
void doit()
{
int autovar = 0;
/* int statvar = 0; */
static int statvar=0;
printf("autovar is %d statvar is %d\n", autovar, statvar);
++autovar;
++statvar;
}
------------------------------------------------------------------------------------
/* znizka.c Przekazywanie zmiennych do funkcji i zwracanie */
#include <stdio.h>
#include <conio.h>
float wartosc(float cena, float rabat);
void main()
{
float cena1, rabat1, wart_netto;
clrscr();
printf("Podaj cene: ");
scanf("%f", &cena1);
printf("Podaj rabat w %: ");
scanf("%f", &rabat1);
wart_netto=wartosc(cena1, rabat1);
printf("main(): Cena z rabatem = %.2f \n", wart_netto);
getch();
}
float wartosc(float cena, float rabat)
{
float redukcja, netto;
redukcja = cena * rabat/100.0;
netto = cena - redukcja;
printf("Funkcja: Cena z rabatem = %.2f\n", netto);
return(netto);
}

------------------------------------------------------
/* Program siln_rek.c */
/* Obliczanie silni met. rekurencyjna */
/*------------------------------------------------------------*/
#include <stdio.h>
#include <conio.h>
#define MAX 16
void main()
{
int n;
unsigned long silnia (long int n);
clrscr();
puts("Obliczenie silni met. rekurencyjna");
for (n=1; n<=MAX; n++)
printf("\n n = %2d n! = %20ld", n, silnia(n));
getch();
} /* main() */

/* Funkcja: obliczanie silni / rekurencja / */
/*---------------------------------------------------*/
unsigned long silnia (long int n)
{
if (n <= 1)
return(1);
else return(n * silnia(n-1));
} /* silnia() */
------------------------------------------------------------------------------------
/* Program siln_iter.c */
/* Obliczanie silni met. iteracyjna */
#include <stdio.h>
#include <conio.h>
#define MAX 15
void main()
{
int n;
long int silnia (int n);
clrscr();
for (n=1; n<=MAX; n++)
printf("\n n = %2d n! = %15ld", n, silnia(n));
getch();
}
/* Funkcja: obliczanie silni / iteracje / */
/*---------------------------------------------------*/
long int silnia (int n)
{
int i;
long int wynik=1;
if (n > 1)
for (i=2; i <= n; ++i)
wynik *= i;
return(wynik);
} /* silnia() */


------------------------------------------------------------------------------------
/* makroin1.C Makroinstrukcje */
#include <stdio.h>
#include <conio.h>
#define ENTER printf("Podaj liczbe: ");
#define Z_F_C(tf) (5.0/9.0)*(tf-32.0)
int main()
{
float tempf, tempc;
clrscr(); /* Kasowanie ekranu */
ENTER
scanf("%f", &tempf);
tempc=Z_F_C(tempf);
printf("%fF = %fC Kontrola: %f\n", tempf, tempc, Z_F_C(tempf));
getch(); /* Czeka na nacisniecie znaku */
return 0; /* Zwraca 0 do systemu operac. */
}
------------------------------------------------------------------------------------
/* luksus.c if ... else */
#include <stdio.h>
#include <conio.h>
void main()
{
float cost, vat, tax, luxury, total;
clrscr();
luxury = 0.0;
printf("Koszt : ");
scanf("%f", &cost);
printf("VAT % : ");
scanf("%f", &vat);
tax = cost * vat/100.0;
if (cost > 40000.00)
{
luxury = cost * 0.005;
printf("Podatek od luksusu= %.2f\n", luxury);
}
else /* if cost <= 40000 */
{
luxury = 0.0;
}
total = cost + tax + luxury;
printf("Koszt calkowity = %.2f", total);
getch();
}
------------------------------------------------------------------------------------
/* Punkty - notowanie wynikow */
#include <stdio.h>
#include <conio.h>
int correct, wrong;
ask(char quest[15], int ans);
main()
{
char question[15];
int answer;
clrscr();
correct = 0;
wrong = 0;
ask("4 + 5 = ", 9);
ask("6 + 2 = ", 8);
ask("5 + 5 = ", 10);
ask("4 + 7 = ", 11);
printf("Odpowiedziales na %d pytan poprawnie.\n", correct);
printf("Na %d pytan zle.\n", wrong);
getch();
return;
} /* main */
ask(char quest[15], int ans)
{
int guess;
printf("%s", quest);
scanf("%d", &guess);
if (guess == ans)
++correct; /* zwiekszanie odpow. dobrych */
else
++wrong; /* zwiekszanie odpow. zlych */
return;
} /* ask */
------------------------------------------------------------------------------------
/* iftax.c Operator logiczny. Warunek logiczny oparty na danych podanych z klawiatury */
#include <stdio.h>
#include <conio.h>
#define VAT 0.22
main()
{
int taxa;
float cost, tax;
clrscr();
tax = 0.0;
printf("Podaj cene produktu: ");
scanf("%f", &cost);
printf("Podaj T jesli towar opodatkowany, N jesli wolny od podatku: ");
fflush(stdin); /* usun zawart bufora standard urzadz we !!!! */
taxa=getchar();
putchar(taxa);
if (taxa == 'T')
tax = cost * VAT;
printf("\nCena brutto = %f", cost + tax);
getch();
return;
}
------------------------------------------------------------------------------------
/* Dwie_zm.c Test 2 zmiennych - operator && (AND) i || (OR) */
#include <stdio.h>
#include <dos.h>
#include <math.h>
#include <string.h>
#include <conio.h>
void main()
{
int ilosob;
float dochod;
clrscr();
puts("Podaj dochod");
scanf("%f", &dochod);
puts("Podaj ilosc osob na utrzymaniu");
scanf("%d", &ilosob);
printf("Ilosc osob %d\n", ilosob);
if (dochod < 20000 && ilosob > 2) /* operator logiczny AND */
puts("Nie placisz podatku");
else
if (dochod < 10000 || ilosob > 1) /* oper.log. OR */
puts("Nie placisz podatku");
else
puts("Placisz!");
getch();
}
------------------------------------------------------------------------------------
/* Program switch.cpp */
/* while warunek {... }; switch-case-default */
// Wariant C++ - wprowadzenie i wyprowadzenie danych
// Komentarz wierszowy w C++
# include <iostream.h> //w C++
#include <conio.h>
int main(void)
{
int ocena=1;
clrscr();
cout << "Klasyfikacja na podstawie oceny\n";
while (ocena != 0)
{
cout << "\nPodaj ocene 1..6, 0 - koniec\n"; // Wydruk w C++
cin >> ocena; // Wprowadzenie danej w C++
switch (ocena)
{ // switch
case 1: cout << "niedost" ; break; // Uwaga na break !!
case 2: cout << "mierny" ; break;
case 3: cout << "dost" ; break;
case 4: cout << "dobry" ; break;
case 5: cout << "b. dobry" ; break;
case 6: cout << "celujacy" ; break;
case 0: cout << "Konczysz prace. OK!"; break;
default: cout << "Blad danych";
} // switch
} // while
getch();
return (0);
} // main
------------------------------------------------------------------------------------
/* tablmnoz.c Tabliczka mnozenia */
/* Petle for zagniezdzone */
#include <stdio.h>
#include <conio.h>
void main()
{
int w, k;
clrscr();
puts("\t\tTabliczka mnozenia\n\n"); /* \t - tabulacja */
for(w=1; w <=10; w++)
{ /* for w */
for(k=1; k<=10; k++) printf("%6d", w*k);
putchar('\n');
} /* for w */
getch();
}
------------------------------------------------------------------------------------
/* do_while.cpp Instrukcja: do instr while wyrazen */
/* Wyznaczenie dlugosci ciagu liczb (calkowitych) zakoncz. zerem */
// Wersja C++
# include <iostream.h>
#include <conio.h>
int main(void)
{
int dlug, liczba, suma;
dlug=0;
suma=0;
clrscr();
cout << "Wyznaczenie dlugosci ciagu liczb (calkowitych) zakoncz. zerem\n";
cout << "Wprowadz kolejne liczby, 0 - koniec\n";
do
{
cin >> liczba;
dlug++;
suma+=liczba; // suma=suma+liczba;
} while (liczba != 0);
cout << "\nDlugosc ciagu liczb = " << dlug;
cout << "\nSuma ciagu = " << suma;
getch();
return (0);
}
------------------------------------------------------------------------------------
/* FORiWHIL.cpp */
/* Instrukcja for(w1; w2;w3) instr; i rownowazna jej w1; while (w2) { instr; w3;} */
/* Wersja C++ */
#include <iostream.h>
#include <conio.h>
#define MAX 7
int main(void)
{
clrscr();
cout << "Druk 6 liczb - metoda for\n";
for (int i=1; i<MAX; i++)
cout << i << endl;
cout << endl; // Nowa linia
{ // jak 1 instrukcja - deklar. lokalne i
cout << "Druk 6 liczb - metoda while - rownowazna for\n";
int i;
i=1;
while (i<7)
{ // while
cout << i << endl;
i++;
} // while
} // jak 1 instrukcja
getch();
return (0);
}
----------------------------------------------------------------------
// fibon.cpp
// Oblicz. liczb. Fibonaciego
// Wersja C++
#include <iostream.h>
#include <conio.h>
#include <iomanip.h>
#define LINIA 6
#define POLE 7
int main(void)
{
int pop, biez, pom, l, n; // poprzednia, biezaca, pomocn, licznik
pop=0;
biez=1;
clrscr();
cout << "Podaj ilosc liczb Fibonaciego: " ;
cin >> n;
cout << endl << "Obliczone liczby: " << endl;
cout << setw(POLE) << pop << setw(POLE) << biez;
for (l=3; l<=n; l++)
{ // for
pom = pop + biez;
pop=biez;
biez=pom;
cout << setw(POLE) << biez;
if (l%LINIA == 0) cout << endl;
} // for
getch();
return (0);
}
------------------------------------------------------------------------------------
// break.cpp
// Iloczyn liczb o podanej dlugosci
// Instrukcja break by wyjsc gdy liczba podana to 0
// Wersja C++
#include <iostream.h>
#include <conio.h>
int main(void)
{
int ilocz, liczba, i, dlug; // iloczyn, liczba, i, dlugosc
int pop; // poprawny
pop=1;
ilocz=1;
liczba=1;
clrscr();
cout << "Podaj ilosc liczb do mnozenia (dlug. ciagu): " ;
cin >> dlug;
cout << endl << "Podaj liczby: " << endl;
for (i=1; i<=dlug; i++)
{ // for
cin >> liczba;
if (liczba == 0)
{
pop=0;
cout << "Blad danych!!!";
break;
}
ilocz *= liczba;
} // for
if (pop)
cout << "Iloczyn = " << ilocz;
else
cout << "Blad danych - 0 ";
getch();
return (0);
}
------------------------------------------------------------------------------------
/* ascii.c */
/* Kody ASCII dla wprowadzonych znakow */
#include <stdio.h>
#include <conio.h>
void main()
{
int litera;
litera = 1;
clrscr();
puts("Kody ASCCI dla podanego znaku, 0 - konczy wprowadzanie");
puts("\tZnak --> Kod\n");
while (litera != '0')
{
fflush(stdin);
litera=getch();
printf("\t%c -----> %d\n",litera, litera);
}
puts("Nacisnij cos");
getch();
}
=================== Tablice =======================================================
/* tabl1.c Tablica wektorowa */
#include <stdio.h>
#include <conio.h>
#define MAX1 5
void main()
{
int temps[MAX1]; /* tablica */
int index, total;
int MAX;
float min, maks;
float average, celsius;
float max;
/* max=(float) MAX; */ /* rzutowanie - zamiana MAX na float */
total=0.0;
clrscr();
puts("Przeliczenie stopni F na C\n");
printf("Podaj ilosc obliczen <= %d : ",MAX);
scanf("%d",&MAX);
/* wprowadz. danych do tablicy */
for(index=0; index < MAX; index++)
{
printf("Podaj temperature #%d: ", index);
scanf("%d",&temps[index]);
}
min=temps[0]; maks=temps[0];
/* obliczenie sumy */
for(index=0; index < MAX; index++)
{
if (temps[index] > maks) maks=temps[index];
if (temps[index] < min) min =temps[index];
total+=temps[index];
/* printf("min: %f maks: %f\n",min, maks); */
}
average=total/MAX; /* srednia */
printf("Srednia : %f\n", average);
printf("Min: %f Max: %f\n\n",min, maks);
puts("Fahrenheit\tCelsius\n");
/* czyta wartosci z tablicy i zamienia */
for(index=0; index < MAX; index++)
{
celsius = (5.0/9.0)*(temps[index]-32);
printf("%d\t\t%6.2f\n",temps[index], celsius);
}
getch();
}
------------------------------------------------------------------------------------
/* tabl2.c Tablica wektorowa */
/* Wyszukiwanie wartosci w tablicy */
#include <stdio.h>
#include <conio.h>
#define MAX1 5
void main()
{
int temps[MAX1]; /* tablica */
int index, total;
int MAX;
float min, maks;
float average, celsius;
float max;
int found;
int wart;
/* max=(float) MAX; */ /* rzutowanie - zamiana MAX na float */
total=0.0;
clrscr();
puts("Przeliczenie stopni F na C\n");
printf("Podaj ilosc obliczen <= %d : ",MAX);
scanf("%d",&MAX);
/* wprowadz. danych do tablicy */
for(index=0; index < MAX; index++)
{
printf("Podaj temperature #%d: ", index);
scanf("%d",&temps[index]);
}
min=temps[0]; maks=temps[0];
/* obliczenie sumy */
for(index=0; index < MAX; index++)
{
if (temps[index] > maks) maks=temps[index];
if (temps[index] < min) min =temps[index];
total+=temps[index];
/* printf("min: %f maks: %f\n",min, maks); */
}
average=total/MAX; /* srednia */
printf("Srednia : %f\n", average);
printf("Min: %f Max: %f\n\n",min, maks);
puts("Fahrenheit\tCelsius\n");
/* czyta wartosci z tablicy i zamienia */
for(index=0; index < MAX; index++)
{
celsius = (5.0/9.0)*(temps[index]-32);
printf("%d\t\t%6.2f\n",temps[index], celsius);
}
puts("Szukanie podanej wartosci");
do
{
printf("Podaj szukana wartosc: 999 koniec ");
scanf("%d", &wart);
index=0; found=0;
while (!found && index <MAX )
{
if (temps[index]==wart)
found=1; else index++;
}
if (!found)
printf ("Nie ma wartosci %d w tablicy\n", wart);
else
printf("Wartosc %d wystepuje na pozycji %d\n", wart, index);
}
while (wart != 999);
getch();
}
------------------------------------------------------------------------------------
/* Tablprzek.c */
/* Przekazywanie tablic */
#include <stdio.h>
#include <conio.h>
#define COUNTM 50
void convert(int heat[]);
int COUNT;
void main()
{ /* main */
int temps[COUNTM];
int index, total;
float celsius;
clrscr();
puts("Funkcja main() - program glowny");
/*load the array with values */
printf("Podaj wielkosc tablicy < %d : ", COUNTM);
scanf("%d",&COUNT);
for(index=0; index < COUNT; index++)
{
printf("Podaj temperature #%d:", index);
scanf("%d",&temps[index]);
} /* for */
/* pass array to convert */
convert(temps);
puts("\nPowrot do programu glownwgo");
getch();
} /* main */
void convert(int heat[])
{ /* convert() */
int index;
float celsius;
puts("\nFunkcja convert()");
puts("Temperatury w st F i C \n");
for(index=0; index <COUNT; index++)
{
celsius = (5.0/9.0)*(heat[index]-32);
printf("%d\t\t%6.2f\n",heat[index], celsius);
}
} /* convert() */
--------------------------------------------------------------------------------
/*pokoje.c*/
/* 2 tablice rownolegle: pokoj[10] i max[10] */
#include <stdio.h>
#include <conio.h>
int pokoj[10]={102, 107, 109, 112,115,116,123,125,127,130};
int max[10]={12,43,23,12,20,15,16,23,12,15};
void main()
{
int index, choice, num, pokoje, flag, found;
clrscr();
pokoje=10;
puts("1. Pokoje wg numerow\n");
puts("2. Wielkosc podanego pokoju\n");
puts("3. Znajdz pokoje o danej wielkosci\n");
printf("Wybierz 1 do 3: ");
scanf("%d", &choice);
if(choice==1)
{ /* 1 */
for(index=0;index <pokoje; index++)
printf("Pokoj %d %d osob maks\n",pokoj[index],max[index]);
} /* 1 */
if(choice==2)
{ /* if 2 */
printf("Podaj numer pokoju: ");
scanf("%d", &num);
index=1;
found=0;
while(!found && index<pokoje)
if(pokoj[index]==num)
found=1;
else
index++;
if(!found)
puts("Nie mozna z tego pokoju skorzystac");
else
printf("Pokoj %d miesci %d osob\n", pokoj[index],max[index]);
} /* if 2 */
if(choice==3)
{ /* 3 */
flag=0;
printf("Min. ilosc osob: ");
scanf("%d", &num);
for(index=0; index<pokoje; index++)
if(max[index]>=num)
{
flag=1;
printf("Pokoj %d miesci %d osob\n",pokoj[index],max[index]);
}
if(flag==0)
puts("Nie ma pokoi takiej wielkosci");
} /* 3*/
getch();
} /* main */
------------------------------------------------------------------------------------
/* Lancuchy.C */
/* Dzialania na lancucha, symulacja gets(), dlugosc lancucha - strlen(),
porownywanie lancuchow - strcmp()
*/
#include <stdio.h>
#include <conio.h>
#include <string.h>
#define MAX 10
void main()
{
char name[MAX], name1[MAX], letter;
int index;
clrscr();
printf("Podaj swoje imie: ");
gets(name1);
printf("Twoje imie: %s", name1);
printf("\n1)Dlugosc napisu: %s = %d ", name1, strlen(name1));
/* Symulacja funckci gets() */
index=0;
puts("\nPodaj jeszcze raz imie i nacisnij Enter");
do
{
letter=getchar();
name[index]=letter;
index++;
}
/* while(letter !='\n' && index < MAX); */
while(letter !='\n');
name[index-1]='\0';
putchar('\n');
puts(name);
printf("Twoje imie 2: %s", name);
printf("\n2) Dlugosc napisu: %s = %d ", name, strlen(name));
if (strcmp(name1, name)==0)
puts ("\nNazwy zgodne");
else
puts ("\nNazwy rozne");
getch();
}
------------------------------------------------------------------------------------
/* TablLanc.c */
/* Tablice lancuchow */
#include <stdio.h>
#include <conio.h>
#include <string.h>
#define W 3
#define K 10
void main()
{
char name[W][K], letter;
int index, index2;
clrscr();
for(index=0; index<(W); ++index) /* zmiana wierszy (napisow) */
{
index2=0; /* nr kolejny znaku w wierszu */
printf("\nWprowadz napis %d, i <Enter> : ", index);
do
{
letter=getchar();
name[index][index2]=letter;
index2++;
}
while (letter !='\n');
name[index][index2-1]='\0';
putchar('\n');
}
for(index=0;index<(W);index++)
{
printf("%s \t\t ma znakow : ",(name[index]));
printf("%d \n",strlen(name[index]));
}
getch();
}
------------------------------------------------------------------------------------
/* CD1.C Struktura danych */
#include <stdio.h>
#include <conio.h>
struct CD
{
char nazwa[20];
char opis[40];
char kategoria[12];
float koszt;
int numer;
} dysk;
void main()
{
clrscr();
puts("Wprowadz dane CD-ROM\n\n");
printf("Nazwa:");
gets(dysk.nazwa);
printf("Opis:");
gets(dysk.opis);
printf("kategoria:");
gets(dysk.kategoria);
printf("koszt:");
scanf("%f", &dysk.koszt);
printf("numer:");
scanf("%d", &dysk.numer);
puts("Informacja na CD :\n");
printf("Nazwa: %s\n",dysk.nazwa);
printf("opis: %s\n",dysk.opis);
printf("kategoria: %s\n",dysk.kategoria);
printf("Koszt: %6.2f\n",dysk.koszt);
printf("Lokalizacja: %d\n",dysk.numer);
getch();
}
------------------------------------------------------------------------------------
/* CD1a.C Struktura danych - deklaracja typu */
#include <stdio.h>
#include <conio.h>
void main()
{
struct CD /* deklaracja nowego typu danych */
{
char nazwa[20];
char opis[40];
char kategoria[12];
float koszt;
int numer;
};
struct CD dysk; /* zmienna dysk typu struct CD */
clrscr();
puts("Wprowadz dane CD-ROM\n\n");

printf("Nazwa:");
gets(dysk.nazwa);
printf("Opis:");
gets(dysk.opis);
printf("kategoria:");
gets(dysk.kategoria);
printf("koszt:");
scanf("%f", &dysk.koszt);
printf("numer:");
scanf("%d", &dysk.numer);
puts("Informacja na CD :\n");
printf("Nazwa: %s\n",dysk.nazwa);
printf("opis: %s\n",dysk.opis);
printf("kategoria: %s\n",dysk.kategoria);
printf("Koszt: %6.2f\n",dysk.koszt);
printf("Lokalizacja: %d\n",dysk.numer);
getch();
}
/**************************************************************/
/*Wprowadzenie do programowania w jezyku C. Roman K. Konieczny*/
/* Program p86.c */
/* ( struktury /1/ ) */
/*------------------------------------------------------------*/
#include <stdio.h>
#include <conio.h>
#define PI 3.1415926
void main() /* przyklad deklaracji oraz dostep do elementow */
{
struct walec
{
int numer;
float promien;
float wysokosc;
char nazwa[20];
};
struct walec a, b, c, d[30];
struct walec w = { 13, 13.13, 3.44, "Walec pascaloidalny" };
float v;
int n;
char s;
clrscr();
/* pobranie zawartosci elementu struktury */
n = w.numer;
v = PI * w.promien * w.promien * w.wysokosc;
s = w.nazwa[6];
printf("\n n = %d, promien = %g, wysokosc = %g, v = %f",
n, w.promien, w.wysokosc, v);
printf("\n %s", w.nazwa);
printf(" n i e %c %c %c %c %c !",s, w.nazwa[10], w.nazwa[11],
w.nazwa[17], w.nazwa[18]);
/* przypisanie wartosci elementom struktury */
d[22].promien = 2.22;
d[22].wysokosc = 7.77;
b.numer = 144;
/*................ itd. */
/* Modyfikacja - wydruk */
printf("\n\n\n");
printf("\nd[22].promien = %g \n",d[22].promien);
printf("b.numer= %d",b.numer);
}
/**************************************************************/
/* Def_str Struktura danych - definicje */
#include <stdio.h>
#include <conio.h>
struct punkt
{
double x, y;
};
struct pracownik
{
char nazwisko[20];
float placa;
int czaspracy;
} prac1={"Kowalski", 2000, 8}, prac2, tab[20];
void main()
{
struct punkt A = {100.0, 200.0};
clrscr();
printf("\nPkt A: x= %f, y= %f ",A.x, A.y);
puts("\n\nWprowadz dane ");
printf("Nazwisko prac nr 2: ");
gets(prac2.nazwisko);
printf("\nNazwisko prac nr 2: %s",prac2.nazwisko);
printf("\nPlaca prac nr 2: ");
scanf("%f", &prac2.placa);
printf("Placa prac nr 2: %5.2f",prac2.placa);
getch();
}
------------------------------------------------------------------------------------
/*cd3.c - Przekazywanie struktury do funkcji */
#include <stdio.h>
#include <conio.h>
struct CD
{
char name[20];
char description[40];
char category[12];
float cost;
int number;
} disc;
void putdisc(struct CD disk); /* function */
void main()
{
clrscr();
puts("Main function - Data of disk\n");
puts("Enter disk information\n\n");
printf("Enter the name:");
gets(disc.name);
printf("Enter the description:");
gets(disc.description);
printf("Enter the category:");
gets(disc.category);
printf("Enter the cost:");
scanf("%f", &disc.cost);
printf("Enter the slot number:");
scanf("%d", &disc.number);
putdisc(disc);
puts("\nMain function");
getch();
} /* main */
void putdisc(struct CD disk) /* function */
{
puts("\nputdisc() function\n");
puts("The information on the CD is:\n\n");
printf("Name: %s\n",disk.name);
printf("Description: %s\n",disk.description);
printf("Category: %s\n",disk.category);
printf("Cost: %6.2f\n",disk.cost);
printf("Location: %d\n",disk.number);
}
------------------------------------------------------------------------------------
/*CD4.C Zwracanie struktury przez funkcje */
#include <stdio.h>
#include <conio.h>
struct CD
{
char name[20];
char description[40];
char category[12];
float cost;
int number;
} disc, getdisc();
struct CD getdisc();
void main()
{
clrscr();
disc=getdisc();
puts("The information on the CD is:\n\n");
printf("Name: %s\n",disc.name);
printf("Description: %s\n",disc.description);
printf("Category: %s\n",disc.category);
printf("Cost: %6.2f\n",disc.cost);
printf("Location: %d\n",disc.number);
} /* main */
/* Funkcja */
struct CD getdisc()
{
struct CD inputdisc;
puts("Enter disk information\n\n");
printf("Enter the name:");
gets(inputdisc.name);
printf("Enter the description:");
gets(inputdisc.description);
printf("Enter the category:");
gets(inputdisc.category);
printf("Enter the cost:");
scanf("%f", &inputdisc.cost);
printf("Enter the slot number:");
scanf("%d", &inputdisc.number);
return(inputdisc);
} /* getdisk() */
//***********************************************************
// Przyk8_3.cpp Wskaznik
// Program z paragrafu 8.3 (str 152) Symfonia C++ Tom I
//***********************************************************
#include <iostream.h>
#include <conio.h>
void main()
{
int zmienna = 8 , drugi = 4 ;
int *wskaznik ;
wskaznik = &zmienna ;
clrscr();
cout << "zmienna = 8, drugi = 4, wskaznik=&zmienna" << endl;
// prosty wypis na ekran ;
cout << "zmienna = " << zmienna
<< "\n a odczytana przez wskaznik = "
<< *wskaznik << endl << endl;
zmienna = 10 ;
cout << "zmienna = 10, drugi = 4, wskaznik=&zmienna" << endl;
cout << "zmienna = "<< zmienna
<< "\n a odczytana przez wskaznik = "
<< *wskaznik << endl << endl;
*wskaznik = 200 ;
cout << "zmienna = ?, drugi = 4, *wskaznik=200" << endl;
cout << " ale wskaznik = &zmienna (stad zmienna = *wskaznik)" << endl;
cout << "zmienna = " << zmienna
<< "\n a odczytana przez wskaznik = "
<< *wskaznik << endl << endl ;
wskaznik = &drugi ;
cout << "zmienna = ? (ostatnio 200), drugi = 4, wskaznik=&drugi" << endl;
cout << "zmienna = "<< zmienna
<< "\n a odczytana przez wskaznik = "
<< *wskaznik << endl << endl;
getch();
}
/**************************************************************/
/* Program p75.c */
/* wskazniki i funkcje */
/*------------------------------------------------------------*/
#include <stdio.h>
void main()
{
int u = 13, v = 33;
void zeruj1(int u, int v);
void zeruj2(int *pu, int *pv);
printf("\nPrzed wywolaniem zeruj1: u = %d v = %d", u,v);
/* u=13, v=33 */
zeruj1(u,v); /* wywolanie funkcji przez nazwe */
printf("\nPo wywolaniu zeruj1: u = %d v = %d", u,v);
/* u=13, v=33 */
zeruj2(&u,&v); /* wywolanie przy pomocy wskaznikow */
printf("\nPo wywolaniu zeruj2: u = %2d v = %2d",u,v);
/* u=0 v=0 */
}
/*----------------------------------------*/
void zeruj1(int u, int v) /* przez wartosc */
{
u = 0;
v = 0;
printf("\n\nW funkcji, wywolaniu zeruj1: u = %d v = %d\n", u,v);
}
/*-----------------------------------------*/
void zeruj2(int *pu, int *pv) /* przy pomocy wskaznikow */
{
*pu = 0;
*pv = 0;
}
/*-----------------------------------------*/
----------------------------------------------------------------------------------------------
/* letcount.c Wskazniki i funkcje */
/* Program wykorzystuje wskazniki do obliczania wartosci */
#include <stdio.h>
#include <conio.h>
countlet(char ndplume[], char alpha, int *count, int *first); /* deklaracja funkcji */
void main()
{
char name[20], letter;
int number, start;
clrscr();
puts("Enter a name: ");
gets(name);
printf("Enter a character: ");
letter=getchar();
countlet(name, letter, &number, &start);
printf("\nThe letter %c is in %s %d times\n",letter, name, number);
printf("Starting position is %d", start);
} /* main() */
/* Funkcja */
countlet(char ndplume[], char alpha, int *count, int *first)
/* char ndplume[], alpha;
int *count, *first;
*/
{
int index, flag;
*count=0;
index=0;
flag=0;
*first=0;
while(ndplume[index] != '\0')
{
if(ndplume[index]== alpha)
{
*count=*count+1;
if(flag==0)
{
*first=index+1;
flag=1;
}
}
index++;
}
return;
} /* countlet() */
/**************************************************************/
/* Program p76.c */
/* Wskazniki. Program zlicza znaki w linii tekstu */

/*------------------------------------------------------------*/
#include <stdio.h>
#include <ctype.h>
main()
{
char linia[80];
int litery = 0; /* liczba liter w linii */
int cyfry = 0; /* liczba cyfr w linii */
int odstepy = 0; /* liczba znakow odstepu */
int inne = 0; /* inne znaki */
int suma; /* calkowita liczba znakow */
int analiza(char linia[], int *l, int *c, int *o, int *i);
printf("\nPodaj linie tekstu: \n");
scanf("%[^\n]", linia);
suma = analiza(linia, &litery, &cyfry, &odstepy, &inne);
printf("\n------ R a p o r t --------------");
printf("\n Liczba znakow = %2d, w tym:", suma);
printf("\n Liczba liter = %2d", litery );
printf("\n Liczba cyfr = %2d", cyfry );
printf("\n Liczba odstepow = %2d", odstepy);
printf("\n Liczba innych = %2d", inne );
return;
} /* main() */
/*-----------------------------------------------------------*/
int analiza(char linia[], int *l, int *c, int *o, int *i)
{
char znak;
int j=0;
while((znak = toupper(linia[j])) != '\0')
{
if (znak >= 'A' && znak <= 'Z')
++ *l; /* litera */
else if (znak >= '0' && znak <= '9')
++ *c; /* cyfra */
else if (znak == ' ' || znak == '\t')
++ *o; /* odstep */
else
++ *i; /* inny znak */
++j;
}
return(j);
}
/*-----------------------------------------------------------*/
/* ==================== PLIKI =====================================================*/
/**************************************************************/
/* Program p97.c */
/* Wyswietlanie zawartosci pliku tekstowego */
/*------------------------------------------------------------*/
#include <stdio.h>
#include <process.h>
#include <conio.h>
void main() /* Czytanie z pliku */
{
FILE *plik_we;
char nazwa[80]; /* nazwa pliku */
int znak;
clrscr();
printf("\n Wyswietlanie zawartosci pliku tekstowego \n");
printf("\n Podaj pelna nazwe pliku: ");
scanf("%s", nazwa);
plik_we = fopen(nazwa,"r"); /* otwarcie pliku do odczytu */
if (plik_we == NULL)
{
printf("\n ....... plik %s nie istnieje \n", nazwa);
exit(1);
}
else
{
while ( (znak = fgetc(plik_we)) != EOF ) /* czyt. znaku */
putc(znak,stdout); /* druk znaku */
fclose(plik_we); /* zamkniecie pliku */
}
getch();
} /* main() */
------------------------------------------------------------------------------------
/* pliktext.c */
/* Zapis znakow do pliku o podanej nazwie, odczyt znakow
a nastepnie linii */
#include <stdio.h>
#include <process.h>
#include <conio.h>
void main()
{
char nazwa[60]; /* nazwa pliku*/
char linia[120]; /* linia tekstu */
FILE *fp;
char letter;
clrscr();
puts("Zapis znakow do pliku tekstowego o podanej nazwie\n");
printf("Podaj nazwe pliku: ");
scanf("%s", nazwa);
if((fp = fopen(nazwa,"w"))==NULL)
{
puts("Nie mozna otworzyc pliku");
exit(1);
}
puts("Wprowadz kolejne znaki, ^Z (Ctrl Z) - koniec wprowadzania");
fflush(stdin); /* czyszczenie bufora we */
/* Wprowadzanie znakow */
do
{
letter=getchar();
fputc(letter, fp);
}
while(letter!=EOF); /* do znaku konca - Ctr Z */
fclose(fp); /* zamkniecie pliku */
printf("Odczyt pliku %s:, znakowo \n\n",nazwa);
if ( (fp=fopen(nazwa,"r") ) == NULL)
{
puts("Nie mozna otworzyc pliku");
exit(1);
}
while ( (letter=fgetc(fp) ) != EOF) /* czytanie znakow do konca pliku */
printf("%c", letter);
fclose(fp);
puts("-----------------------------------------------\n");
printf("\n\nOdczyt pliku %s:, wierszami \n\n",nazwa);
fp=fopen(nazwa,"r");
while ( fgets(linia, 120, fp) != NULL ) /* wczytanie wiersza */
{
printf(linia);
}
fclose(fp);
getch();
} /* main() */
------------------------------------------------------------------------------------
/* fprintf.c* /
/* Zapis sformatowanych informacji wyjsciowych do pliku i odczyt z pliku */
#include "stdio.h"
#include <process.h>
#include <string.h>
#include <conio.h>
#include <ctype.h> /* wymaga funkcja touuper() */
void main()
{
FILE *fp; /* deklaracja zmiennej plikowej */
char name[20]; /* nazwa towaru */
int quantity;
float cost;
clrscr();
/* Zapis do pliku MYFILE */
if((fp = fopen("MYFILE","w"))==NULL)
{
puts("Nie moge otworzyc pliku");
exit(1);
}
printf("Podaj nazwe produktu (K - koniec): ");
scanf("%s",name); /* nazwa produktu */
while ( (strlen(name)>1) && (toupper(name[1]) !='K') )
{
printf("Cena: ");
scanf("%f", &cost);
printf("Ilosc: ");
scanf("%d", &quantity);
fprintf(fp, "%s %f %d\n", name, cost, quantity);
printf("Nazwa (K - Koniec) : ");
/* gets(name); */
scanf("%s",name);
/* if ((toupper(name[1])=='K') && (strlen(name)==1)) break; */
}
fclose(fp);
/* Odczyt z pliku MYFILE */
if((fp = fopen("MYFILE","r"))==NULL)
{
puts("Nie moge otworzyc pliku");
exit();
}
while(fscanf(fp,"%s %f %d", name, &cost, &quantity) != EOF)
{
printf("Produkt: %s\n", name);
printf("Cena: %.2f\n", cost);
printf("Ilosc: %d\n", quantity);
}
fclose(fp);

puts("\nNacisnij cos by wyjsc z programu");
getch();
}
------------------------------------------------------------------------------------
/* Program p100.c */
/* Kopiowanie pliku tekstowego na drugi (nazwy podajemy) */
#include <stdio.h>
#include <process.h>
#include <conio.h>
void main() /* Kopiowanie pliku */
{
FILE *plik_we, *plik_wy;
char nazwa_we[80], nazwa_wy[80];
int znak;
clrscr();
printf("\n Kopiowanie zawartosci pliku \n");
printf("\n Podaj nazwe pliku wejsciowego: ");
scanf("%s", nazwa_we);
plik_we = fopen(nazwa_we,"r"); /* otwarcie pliku do odczytu */
if (plik_we == NULL)
{
printf("\n ....... plik %s nie istnieje \n", nazwa_we);
exit(1);
}
printf("\n Podaj nazwe pliku wyjsciowego (lpt1 - drukarka): ");
scanf("%s", nazwa_wy);
plik_wy = fopen(nazwa_wy,"w"); /* otwarcie pliku do zapisu */
while ( (znak = fgetc(plik_we)) != EOF ) /* czytanie */
putc(znak,plik_wy); /* kopiowanie */
fclose(plik_we);
fclose(plik_wy);
scanf("Przekopiowano plik %s na plik %s \n",nazwa_we, nazwa_wy);
puts("\nNacisnij cos ...");
getch();
}
------------------------------------------------------------------------------------
/* Program p101.c */
/* Kopiowanie pliku na plik blokami */
#include <stdio.h>
#include <alloc.h>
#include <process.h>
#include <conio.h>
void main() /* Kopiowanie pliku blokami */
{
FILE *plik_we, *plik_wy;
char nazwa_we[80], nazwa_wy[80];
char *p; /* pomocniczy wskaznik */
long r; /* rozmiar pliku */
clrscr();
printf("\n Kopiowanie zawartosci pliku (blokami) \n");
printf("\n Podaj nazwe pliku wejsciowego: ");
scanf("%s", nazwa_we);
plik_we = fopen(nazwa_we,"r"); /* otwarcie pliku do odczytu */
if (plik_we == NULL)
{
printf("\n ....... plik %s nie istnieje \n", nazwa_we);
exit(1);
}
printf("\n Podaj nazwe pliku wyjsciowego: ");
scanf("%s", nazwa_wy);
plik_wy = fopen(nazwa_wy,"w"); /* otwarcie pliku do zapisu */
fseek(plik_we,0,SEEK_END);
r = ftell(plik_we);
p = (char *) malloc(r); /* rezerwacja pamieci dla pliku */
rewind(plik_we);
fread (p, 1, r, plik_we); /* wprowadzenie pliku do pamieci */
fwrite(p, 1, r, plik_wy); /* wyprowadzenie pliku z pamieci */
fclose(plik_we);
fclose(plik_wy);
puts("\nPrzekopiowano. Nacisnij cos");
getch();
}
------------------------------------------------------------------------------------
/* Program p103a.c */
/* Wydruk obliczen do pliku */
/*------------------------------------------------------------*/
#include <stdio.h>
#include <conio.h>
#define VPOCZ 200
#define VKONC 300
#define KROK 10
void main() /* zapis wynikow do pliku */
{
FILE *plik_wy;
int v;
float vm;
char nazwa_wyn[50];
clrscr();
printf("\nPodaj nazwe pliku wynikow: ");
scanf("%s",nazwa_wyn);
/* plik_wy = fopen("wyniki.103","w"); */
plik_wy = fopen(nazwa_wyn,"w");
fprintf(plik_wy,"\n-------------------------------------");
fprintf(plik_wy,"\n Predkosc [km/h] Predkosc [m/s] ");
fprintf(plik_wy,"\n-------------------------------------");
v = VPOCZ;
while ( v <= VKONC )
{
vm = v / 3.6 ;
fprintf(plik_wy,"\n %3i %6.2f", v, vm);
v += KROK;
}
fprintf(plik_wy,"\n-------------------------------------");
fclose(plik_wy);
}

------------------------------------------------------------------------------------
/* Sortowanie babelkowe z zapamietaniem wskaznika zamiany */
#include <stdio.h>
#include <conio.h>
#define NM 100
int a[NM], n;
/* Deklaracja funkcji */
void sort (int *a);
void dane();
void wyniki();
/* Program glowny */
void main()
{
dane();
printf("\nWprowadzono: \n");
wyniki();
sort(a);
printf("\n\nPo sortowaniu\n ");
wyniki();
getch();
} {main}
/* Definicja funkcji */
void sort (int *a)
{
int i, j, iw, temp;
for(i=1, iw=i; i<=n; i++)
for (j=n; j>=iw; j--)
if ( a[j] < a[j-1] )
{ temp=a[j];
a[j]=a[j-1];
a[j-1]=temp;
iw=j-1;
}
}
void dane()
{
int i;
clrscr();
printf("Ilosc elementow tablicy ");
scanf("%d",&n);
if (n> NM)
n=NM;
for (i=1; i<=n; i++)
{
printf("\n a[%d] ",i);
scanf("%d",&a[i]);
/*printf("\ni=%d a=%d",i,a[i]); */
}
}
void wyniki()
{
int i;
printf("\nWyniki\n");
for (i=1; i<=n; i++)
printf("\n%d %d",i, a[i]);
}
/* Koniec definicji funkcji i koniec listingu calego programu */
-----------------------------------------------------------------
/* Program S.C - sortowanie przez wstawianie */
#include <stdio.h>
#include <conio.h>
#define max 100 /* max rozmiar tablicy */
int n,i,j;
float x;
float t[max];
void main (void)
{
clrscr();
printf("===== Program S.C ============= \n");
printf("\nSortowanie przez wstawianie");
printf("\n\nWprowadz ilosc liczb < %i : ",max);
scanf("%i",&n);
printf("\nWprowadz kolejne liczby : \n");
for (i=1; i<=n; i++)
{
printf("%i " ,i);
scanf(" %f",&t[i]);
}
printf("\nPrzed sortowaniem: \n");
for (i=1; i<=n; i++)
{
printf("\n%i %f",i,t[i]);
}
printf("\n");
for (i=2; i<=n; i++)
{
x=t[i];
t[0]=x;
j=i-1;
while (x<t[j])
{
t[j+1]=t[j];
j=j-1;
} /* while */
t[j+1]=x;
}; /* for */
printf("\nPo sortowaniu");
for (i=1; i<=n; i++)
{
printf("\n%i %f",i,t[i]);
}
printf("\n\nNacisnij cos ");
getch();
clrscr();
} /* sortowanie przez wstawianie */
-------------------------------------------------------
/* Program NWD.c – najwiekszy wspolny dzielnik */
#include <stdio.h>
#include <conio.h>
int a,b,a1,b1, nwd;
char ch;
int main (void)
{
nwd=0;
a=0;
b=0;
clrscr();
printf("===== Program NWD.C ============= \n");
printf("\nProgram oblicza NWD 2 liczb naturalnych, met. Euklideasa");
printf("\nprzez pomniejszanie wiekszej liczby o mniejsza az do rownosci");
printf("\n\nWprowadz liczby oddzielone spacja: ");
scanf("%i %i",&a, &b);
fflush(stdin); /* flush the input stream in case of bad input */
printf("\na=%i b=%i\n",a,b);
a1=a;
b1=b;
while (a != b)
{
if (a > b)
{
a=a-b;
printf("\na=%i",a);
}
else
{
b=b-a;
printf("\nb=%i",a);
}
}; /* while */
nwd=a;
printf("\n\nNWD liczb %i i %i = %i\n",a1,b1,nwd);
printf("\nNacisnij cos ");
ch = getche();
clrscr();
return 0;
}