B-PROG2 Materiály 2020

Materiály 2020

/*Globalne a lokalne premenne*/

#include <stdio.h>

//globalna premenna: kazdy ju moze citat a modifikovat
int x = 3;

//void: bezhodnotovy typ
void fun1(void)
{
	printf("Fun1: %i\n", x);
}

void fun2(int x)
{
	//lokalny parameter x nahradi globalnu premennu x
	printf("Fun2: %i\n", x);
}

int main()
{
	int x = 2;
	//lokalna premenna x nahradi globalnu premennu x
	
	printf("main: %i\n", x);
	
	//TODO: co sa zmeni, ak dam fun1(x), fun2(x)?
	fun1();
	fun2(7);
	
	return 0;
}

/*Globalne a lokalne premenne*/

#include <stdio.h>

//globalna premenna: kazdy ju moze citat a modifikovat

int x = 3;

//void: bezhodnotovy typ

void fun1(void)

{

printf("Fun1: %i\n", x);

}

void fun2(int x)

{

//lokalny parameter x nahradi globalnu premennu x

printf("Fun2: %i\n", x);

}

int main()

{

int x = 2;

//lokalna premenna x nahradi globalnu premennu x

printf("main: %i\n", x);

//TODO: co sa zmeni, ak dam fun1(x), fun2(x)?

fun1();

fun2(7);

return 0;

}

/* Demo01: Celocislene delenie */
#include <stdio.h>

int main( )
{
	int a, b, c;

	while ( 1 == 1 )
	{
		printf("Zadaj 2 cisla:");
		scanf("%d", &a);
		scanf("%d", &b);
		
		if (b == 0)
		{
			return -1;
		}
		
		c = a/ b;
		printf("%i / %i = %i\n", a, b, c);

		c = a % b;
		printf("%i mod %i = %i\n", a, b, c);
		
	}
    return 0;
}

/* Demo01: Celocislene delenie */

#include <stdio.h>

int main( )

{

int a, b, c;

while ( 1 == 1 )

{

printf("Zadaj 2 cisla:");

scanf("%d", &a);

scanf("%d", &b);

if (b == 0)

{

return -1;

}

c = a/ b;

printf("%i / %i = %i\n", a, b, c);

c = a % b;

printf("%i mod %i = %i\n", a, b, c);

}

return 0;

}

/* Demo02: Floating point delenie */
#include <stdio.h>

int main( )
{
	double a, b, c = 3.4e-3;

	while ( 1 == 1 )
	{
		printf("Zadaj 2 cisla:");
		scanf("%lf", &a);
		scanf("%lf", &b);
		
		if (b == 0.0)
			return -1;
		
		c = a / b;
		printf("%lf / %lf = %lf\n", a, b, c);

		//c = a % b;
		//printf("%lf mod %lf = %lf\n", a, b, c);
		
	}
    return 0;
}

/* Demo02: Floating point delenie */

#include <stdio.h>

int main( )

{

double a, b, c = 3.4e-3;

while ( 1 == 1 )

{

printf("Zadaj 2 cisla:");

scanf("%lf", &a);

scanf("%lf", &b);

if (b == 0.0)

return -1;

c = a / b;

printf("%lf / %lf = %lf\n", a, b, c);

//c = a % b;

//printf("%lf mod %lf = %lf\n", a, b, c);

}

return 0;

}

/* Konverzia datovych typov:
   explicitna: operator (TYP)
   implicitna: 
     podla pravidiel zo standardu: 
	   a) na spolocny vacsi typ
	   b) podla typu premennej, kam sa zapisuje
 */
#include <stdio.h>

int main( )
{
	int a, b, c;
	double x, y, z;

	while ( 1 == 1 )
	{
		printf("Zadaj 2 cisla:");
		scanf("%d", &a);
		scanf("%d", &b);
		
		if (b == 0)
			return -1;
		
		c = a / b;
		printf("Celociselne: %i / %i = %i\n", a, b, c);

		c = a % b;
		printf("Zvysok: %i mod %i = %i\n", a, b, c);
		
		//x = (double) a; y = (double) b;
		//z = x / y;
		z = a / (double) b;
		
		printf("Necelociselne: %.0lf / %.0lf = %lf\n", 
		                      (double)a, (double)b, z);
		
		z = (int) (z+0.5);
		printf("Zaokruhlene: %lf\n", z);
		
	}
    return 0;
}

/* Konverzia datovych typov:

explicitna: operator (TYP)

implicitna:

podla pravidiel zo standardu:

a) na spolocny vacsi typ

b) podla typu premennej, kam sa zapisuje

#include <stdio.h>

int main( )

{

int a, b, c;

double x, y, z;

while ( 1 == 1 )

{

printf("Zadaj 2 cisla:");

scanf("%d", &a);

scanf("%d", &b);

if (b == 0)

return -1;

c = a / b;

printf("Celociselne: %i / %i = %i\n", a, b, c);

c = a % b;

printf("Zvysok: %i mod %i = %i\n", a, b, c);

//x = (double) a; y = (double) b;

//z = x / y;

z = a / (double) b;

printf("Necelociselne: %.0lf / %.0lf = %lf\n",

(double)a, (double)b, z);

z = (int) (z+0.5);

printf("Zaokruhlene: %lf\n", z);

}

return 0;

}

/* Demo03: Rozne celociselne typy */
#include <stdio.h>
#include <stdint.h>    // doplnkove definicie typov
#include <limits.h>    // pomocne konstanty - rozsahy typu

//vlastna definicia typu:
typedef unsigned short int word;

int main( )
{
	int                iP1  = -1;
	short int          siP2 = 100000;         //pretecenie
	char               cP3  = 65;             //cislo aj znak (default: ASCII kodovane)
	unsigned long int  ulP4 = 0xdeadbeef;     //hexa zadana konstanta 
    unsigned long long llP5 = -1;             //int sa da vynechat, -1 sa skonvertuje na unsigned
	word               wP6  = 0100;           //nas vlastny typ, osmickova sustava 
    int64_t            qwP7 = -1;             //alternativna definicia z stdint.h
        
    //TODO: priradit spravne format stringy
    printf("1. %i, size = %iB\n",  iP1, sizeof(iP1));
    printf("2. %i, size = %iB\n", siP2, sizeof(siP2));
    printf("3. %i, size = %iB\n",  cP3, sizeof(cP3));
    printf("4. %i, size = %iB\n", ulP4, sizeof(ulP4));
    printf("5. %i, size = %iB\n", llP5, sizeof(llP5));
    printf("6. %i, size = %iB\n",  wP6, sizeof(wP6));
    printf("7. %i, size = %iB\n", qwP7, sizeof(qwP7));
   
    //TODO: ostatne typy
    printf("Hranice int: od %i do %i\n", INT_MIN, INT_MAX);

    return 0;
}

/* Demo03: Rozne celociselne typy */

#include <stdio.h>

#include <stdint.h> // doplnkove definicie typov

#include <limits.h> // pomocne konstanty - rozsahy typu

//vlastna definicia typu:

typedef unsigned short int word;

int main( )

{

int iP1 = -1;

short int siP2 = 100000; //pretecenie

char cP3 = 65; //cislo aj znak (default: ASCII kodovane)

unsigned long int ulP4 = 0xdeadbeef; //hexa zadana konstanta

unsigned long long llP5 = -1; //int sa da vynechat, -1 sa skonvertuje na unsigned

word wP6 = 0100; //nas vlastny typ, osmickova sustava

int64_t qwP7 = -1; //alternativna definicia z stdint.h

//TODO: priradit spravne format stringy

printf("1. %i, size = %iB\n", iP1, sizeof(iP1));

printf("2. %i, size = %iB\n", siP2, sizeof(siP2));

printf("3. %i, size = %iB\n", cP3, sizeof(cP3));

printf("4. %i, size = %iB\n", ulP4, sizeof(ulP4));

printf("5. %i, size = %iB\n", llP5, sizeof(llP5));

printf("6. %i, size = %iB\n", wP6, sizeof(wP6));

printf("7. %i, size = %iB\n", qwP7, sizeof(qwP7));

//TODO: ostatne typy

printf("Hranice int: od %i do %i\n", INT_MIN, INT_MAX);

return 0;

}

/* Demo04: Floating point typy */
#include <stdio.h>
#include <float.h>

int main( )
{
	float  fx = 0.01;
	double dx = 0.01;
 
    printf("The maximum value of float = %.10e\n", FLT_MAX);
    printf("The minimum value of float = %.10e\n", FLT_MIN);

    printf("The maximum value of double = %.10e\n", DBL_MAX);
    printf("The minimum value of double = %.10e\n", DBL_MIN);

    printf("Float : %0.3f = %0.30f\n", fx, fx);
    printf("Double: %0.3lf = %0.308lf\n", dx, dx);

    return 0;
}

/* Demo04: Floating point typy */

#include <stdio.h>

#include <float.h>

int main( )

{

float fx = 0.01;

double dx = 0.01;

printf("The maximum value of float = %.10e\n", FLT_MAX);

printf("The minimum value of float = %.10e\n", FLT_MIN);

printf("The maximum value of double = %.10e\n", DBL_MAX);

printf("The minimum value of double = %.10e\n", DBL_MIN);

printf("Float : %0.3f = %0.30f\n", fx, fx);

printf("Double: %0.3lf = %0.308lf\n", dx, dx);

return 0;

}

/*Ukazka: je potrebne mat spravne typy pri stdio funkciach
     ak zle printf: hodnoty sa nespravne vypisu
	 ak zle scanf: hodnoty sa nespravne nacitaju
	               moze dojst k padu programu (nedostatok pamate) 
 */

#include <stdio.h>

int main()
{
	int a, b, c;
	double x, y, z;
	
	printf("x? ");
	scanf("%lf", &x);
	
	a = (int)x;
	
	printf("x %%i: %i\n", x);
	printf("x %%f: %lf\n", x);
	printf("a %%i: %i\n", a);
	printf("a %%f: %lf\n", a);
	
	
	return 0;
}

/*Ukazka: je potrebne mat spravne typy pri stdio funkciach

ak zle printf: hodnoty sa nespravne vypisu

ak zle scanf: hodnoty sa nespravne nacitaju

moze dojst k padu programu (nedostatok pamate)

#include <stdio.h>

int main()

{

int a, b, c;

double x, y, z;

printf("x? ");

scanf("%lf", &x);

a = (int)x;

printf("x %%i: %i\n", x);

printf("x %%f: %lf\n", x);

printf("a %%i: %i\n", a);

printf("a %%f: %lf\n", a);

return 0;

}

#include <stdio.h>
#include <math.h>

//ukazka vyuzitia makier: pomenovana konstanta, makro deg2rad
#define RADIUS_EARTH_KM 6372
#define RADIUS_MARS_KM 4000
#define deg2rad(X) ((X)*M_PI/180)

//Vrati vzdialenost dvoch GPS bodov v km
double distance(double phi1, double lambda1, double phi2, double lambda2)
{
   double d, z, u, v;

   //konverzia na radiany!
   phi1 = deg2rad(phi1);
   phi2 = deg2rad(phi2);
   lambda1 = deg2rad(lambda1);
   lambda2 = deg2rad(lambda2);

   //predvypocet sinusov, ktore sa potom umocnia na druhu
   u = sin((phi2 - phi1) / 2.0);
   v = sin((lambda2 - lambda1) / 2.0);

   //vypocet vnutornej casti vzorca
   z = sqrt(u*u + cos(phi1)*cos(phi2)*v*v);
   //finalizacia
   d = 2.0*RADIUS_MARS_KM*asin(z);

   return d;
}

double getLat()
{
   int deg, min;

   printf("Zemepisna sirka. Stupne (N+, S-):");
   scanf("%d", &deg);
   printf("Minuty:");
   scanf("%d", &min);

   return deg + min/60.0;
}

double getLon()
{
   int deg, min;

   printf("Zemepisna dlzka. Stupne (E+, W-):");
   scanf("%d", &deg);
   printf("Minuty:");
   scanf("%d", &min);

   return deg + min/60.0;
}

int main()
{
   double lat1, lon1, lat2, lon2, d;

   while (1==1)
   {
      printf("Zadaj prvy bod.\n");
      lat1 = getLat();
      lon1 = getLon();

      printf("Zadaj druhy bod.\n");
      lat2 = getLat();
      lon2 = getLon();

      d = distance(lat1, lon1, lat2, lon2);
      printf("Ich vzdialenost je: %0.3lf km\n", d);
   }

   return 0;
}

#include <stdio.h>

#include <math.h>

//ukazka vyuzitia makier: pomenovana konstanta, makro deg2rad

#define RADIUS_EARTH_KM 6372

#define RADIUS_MARS_KM 4000

#define deg2rad(X) ((X)*M_PI/180)

//Vrati vzdialenost dvoch GPS bodov v km

double distance(double phi1, double lambda1, double phi2, double lambda2)

{

double d, z, u, v;

//konverzia na radiany!

phi1 = deg2rad(phi1);

phi2 = deg2rad(phi2);

lambda1 = deg2rad(lambda1);

lambda2 = deg2rad(lambda2);

//predvypocet sinusov, ktore sa potom umocnia na druhu

u = sin((phi2 - phi1) / 2.0);

v = sin((lambda2 - lambda1) / 2.0);

//vypocet vnutornej casti vzorca

z = sqrt(u*u + cos(phi1)*cos(phi2)*v*v);

//finalizacia

d = 2.0*RADIUS_MARS_KM*asin(z);

return d;

}

double getLat()

{

int deg, min;

printf("Zemepisna sirka. Stupne (N+, S-):");

scanf("%d", &deg);

printf("Minuty:");

scanf("%d", &min);

return deg + min/60.0;

}

double getLon()

{

int deg, min;

printf("Zemepisna dlzka. Stupne (E+, W-):");

scanf("%d", &deg);

printf("Minuty:");

scanf("%d", &min);

return deg + min/60.0;

}

int main()

{

double lat1, lon1, lat2, lon2, d;

while (1==1)

{

printf("Zadaj prvy bod.\n");

lat1 = getLat();

lon1 = getLon();

printf("Zadaj druhy bod.\n");

lat2 = getLat();

lon2 = getLon();

d = distance(lat1, lon1, lat2, lon2);

printf("Ich vzdialenost je: %0.3lf km\n", d);

}

return 0;

}

int main(){
	int test;
	
	test = 2 > 0;
	printf("  test: %i\n", test);
	
	test = !test;
	printf(" !test: %i\n", test);

	if (test = 2)
	{
		printf("  test: %i\n", test);
		printf("!!test: %i\n", !!test);
	}
	
	while(
	   scanf("%i", &test) 
	       && ( //tato zatvorka je nutna, preco?  priklad ked nie je: -2, a
		            ( test > 0 && printf("test je kladny\n")  )
	             || ( test < 0 && printf("test je zaporny\n") )
			  )
	     )
	{
		//empty, TODO: jednoprikazovy prazdny if/while...
	}
	
	
	     
	return 0;
}

int main(){

int test;

test = 2 > 0;

printf(" test: %i\n", test);

test = !test;

printf(" !test: %i\n", test);

if (test = 2)

{

printf(" test: %i\n", test);

printf("!!test: %i\n", !!test);

}

while(

scanf("%i", &test)

&& ( //tato zatvorka je nutna, preco? priklad ked nie je: -2, a

( test > 0 && printf("test je kladny\n") )

|| ( test < 0 && printf("test je zaporny\n") )

)

{

//empty, TODO: jednoprikazovy prazdny if/while...

}

return 0;

}

#include 

//vrati pocet dni v mesiaci (cislovane od 1)
int pocet_dni(int mesiac)
{
	int pocet;
	
	if (mesiac == 2)
	{
		pocet = 28;  // pocet = 28 + jeprestupny(rok)
    } 
	else if (mesiac == 4 || mesiac == 6 || mesiac == 9 || mesiac == 11)
    {
    	pocet = 30;
	}
	else if (mesiac > 0 && mesiac <= 12)
	{
		pocet = 31;
	}
	else //ostatne pripady
	{
		pocet = 0;
	}
	
	return pocet;
}


//vrati pocet dni v mesiaci (cislovane od 1)
int pocet_dni_switch(int mesiac)
{
	int pocet = 0;
	
	switch (mesiac)
	{
		case 2:
			pocet = 28;  // pocet = 28 + jeprestupny(rok)
			break;
		case 1:
		case 3:
		case 5:
		case 7:
		case 8:
		case 10:
		case 12:
			pocet = 31;
			break;
		default:
			pocet = 30;
			break;
		//TODO: nekontroluje sa nespravny mesiac...
	}
	
	return pocet;
}

//pre kazdy mesiac, vypis pocet dni
void vypis_dni()
{
	int mesiac;
	
	//inicializacia pred cyklom
	mesiac = 1;
	
	//CYKLUS s podmienkou
	while (mesiac <= 12)
	{
		//telo cyklu
		printf("Mesiac c. %2d ma %2d dni.\n",
		                mesiac, pocet_dni(mesiac));
		
		//AKTUALIZACIA premennej cyklu
		mesiac++;    //aka: mesiac = mesiac + 1;
	}
	
	//finalizacia za cyklom
}


//pre kazdy mesiac, vypis pocet dni
void vypis_dni_for()
{
	int mesiac;
	
	for ( mesiac = 1;         //inicializacia pred cyklom
	        mesiac <= 12; //podmienka cyklu mesiac++ ) //AKTUALIZACIA premennej cyklu, // vzdy na konci vykonaneho tela cyklu tesne pred kontrolou podmienky { //telo cyklu printf("Mesiac c. %2d ma %2d dni.\n", mesiac, pocet_dni(mesiac)); } //finalizacia za cyklom } //nacita mesiac a vypise jeho pocet dni, // vrati 0, ak zlyhalo nacitanie mesiaca int vypis_dni_dowhile() { int mesiac; //TODO: overit nacitanie? do { printf("Zadaj cislo mesiaca: "); scanf("%d", &mesiac); //TODO: break, ak sa nacitalo nieco zle printf("Mesiac c. %2d ma %2d dni.\n", mesiac, pocet_dni(mesiac)); } while (mesiac >= 1 && mesiac <= 12);
	
	return 1;	
}

int main()
{
	vypis_dni();
	vypis_dni_dowhile();
	
	return 0;
}

#include

//vrati pocet dni v mesiaci (cislovane od 1)

int pocet_dni(int mesiac)

{

int pocet;

if (mesiac == 2)

{

pocet = 28; // pocet = 28 + jeprestupny(rok)

}

else if (mesiac == 4 || mesiac == 6 || mesiac == 9 || mesiac == 11)

{

pocet = 30;

}

else if (mesiac > 0 && mesiac <= 12)

{

pocet = 31;

}

else //ostatne pripady

{

pocet = 0;

}

return pocet;

}

//vrati pocet dni v mesiaci (cislovane od 1)

int pocet_dni_switch(int mesiac)

{

int pocet = 0;

switch (mesiac)

{

case 2:

pocet = 28; // pocet = 28 + jeprestupny(rok)

break;

case 1:

case 3:

case 5:

case 7:

case 8:

case 10:

case 12:

pocet = 31;

break;

default:

pocet = 30;

break;

//TODO: nekontroluje sa nespravny mesiac...

}

return pocet;

}

//pre kazdy mesiac, vypis pocet dni

void vypis_dni()

{

int mesiac;

//inicializacia pred cyklom

mesiac = 1;

//CYKLUS s podmienkou

while (mesiac <= 12)

{

//telo cyklu

printf("Mesiac c. %2d ma %2d dni.\n",

mesiac, pocet_dni(mesiac));

//AKTUALIZACIA premennej cyklu

mesiac++; //aka: mesiac = mesiac + 1;

}

//finalizacia za cyklom

}

//pre kazdy mesiac, vypis pocet dni

void vypis_dni_for()

{

int mesiac;

for ( mesiac = 1; //inicializacia pred cyklom

mesiac <= 12; //podmienka cyklu mesiac++ ) //AKTUALIZACIA premennej cyklu, // vzdy na konci vykonaneho tela cyklu tesne pred kontrolou podmienky { //telo cyklu printf("Mesiac c. %2d ma %2d dni.\n", mesiac, pocet_dni(mesiac)); } //finalizacia za cyklom } //nacita mesiac a vypise jeho pocet dni, // vrati 0, ak zlyhalo nacitanie mesiaca int vypis_dni_dowhile() { int mesiac; //TODO: overit nacitanie? do { printf("Zadaj cislo mesiaca: "); scanf("%d", &mesiac); //TODO: break, ak sa nacitalo nieco zle printf("Mesiac c. %2d ma %2d dni.\n", mesiac, pocet_dni(mesiac)); } while (mesiac >= 1 && mesiac <= 12);

return 1;

}

int main()

{

vypis_dni();

vypis_dni_dowhile();

return 0;

}

#include 

//vrati pocet dni v mesiaci (cislovane od 1)
int pocet_dni(int mesiac)
{
	int pocet = 0;
	
	if (mesiac <= 0 || mesiac > 12)
		return pocet;
		
	pocet = 30 + 
	       ((mesiac + (mesiac > 7)) % 2) 
		   - 2*(mesiac == 2);
	
	return pocet;
}

//pre kazdy mesiac, vypis pocet dni
void vypis_dni()
{
	int mesiac;

    for ( scanf("%i", &mesiac);  
	         pocet_dni(mesiac)!= 0 ;
			    scanf("%i", &mesiac)   ) 
    {
    	printf("%i : %i \n", mesiac, pocet_dni(mesiac));
 	
	}
    
    //POST: mesiac == 13
}

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

#include

//vrati pocet dni v mesiaci (cislovane od 1)

int pocet_dni(int mesiac)

{

int pocet = 0;

if (mesiac <= 0 || mesiac > 12)

return pocet;

pocet = 30 +

((mesiac + (mesiac > 7)) % 2)

- 2*(mesiac == 2);

return pocet;

}

//pre kazdy mesiac, vypis pocet dni

void vypis_dni()

{

int mesiac;

for ( scanf("%i", &mesiac);

pocet_dni(mesiac)!= 0 ;

scanf("%i", &mesiac) )

{

printf("%i : %i \n", mesiac, pocet_dni(mesiac));

}

//POST: mesiac == 13

}

int main()

{

vypis_dni();

return 0;

}

Prednáška 5: smerníky (pointers) [PDF]

#include <stdio.h>

void fun(int pole[], int i, int j)
{
    int tmp;
    if (i < j)
    {
        tmp     = pole[i];
    	pole[i] = pole[j];
    	pole[j] = tmp;
    	fun(pole, i+1, j-1);
    }   
}

int main()
{
	int test[] = {1,2,3,4,5,6,7,8,9};
	int i, n = sizeof(test)/sizeof(test[0]);
	
	fun(test, 0, n-1);
	
	for (i = 0; i < n; i++)
		printf("%i ", test[i]);
	
	return 0;
}

#include <stdio.h>

void fun(int pole[], int i, int j)

{

int tmp;

if (i < j)

{

tmp = pole[i];

pole[i] = pole[j];

pole[j] = tmp;

fun(pole, i+1, j-1);

}

int main()

{

int test[] = {1,2,3,4,5,6,7,8,9};

int i, n = sizeof(test)/sizeof(test[0]);

fun(test, 0, n-1);

for (i = 0; i < n; i++)

printf("%i ", test[i]);

return 0;

}

#include <stdio.h>

//vstupom funkcie su dve adresy, ulozene do smernikov p1 a p2
void swap(int *p1, int *p2)
{
	int tmp;
	
    tmp = *p1;  
    *p1 = *p2;
    *p2 = tmp;	
}

void fun(int pole[], int i, int j)
{
    if (i < j)
    {
     //volanie swap, vstupom musia byt dve adresy intov
     // tieto adresy nemusia odkazovat na nase udaje, mozu to byt ine adresy, ktore mame dostupne
    	swap(&pole[i], &pole[j]);
    	fun(pole, i+1, j-1);
    }   
}


int main()
{
	int test[] = {1,2,3,4,5,6,7,8,9};
	int i, n = sizeof(test)/sizeof(test[0]);
	
	fun(test, 0, n-1);
	
	for (i = 0; i < n; i++)
		printf("%i ", test[i]);
	
	return 0;
}

#include <stdio.h>

//vstupom funkcie su dve adresy, ulozene do smernikov p1 a p2

void swap(int *p1, int *p2)

{

int tmp;

tmp = *p1;

*p1 = *p2;

*p2 = tmp;

}

void fun(int pole[], int i, int j)

{

if (i < j)

{

//volanie swap, vstupom musia byt dve adresy intov

// tieto adresy nemusia odkazovat na nase udaje, mozu to byt ine adresy, ktore mame dostupne

swap(&pole[i], &pole[j]);

fun(pole, i+1, j-1);

}

int main()

{

int test[] = {1,2,3,4,5,6,7,8,9};

int i, n = sizeof(test)/sizeof(test[0]);

fun(test, 0, n-1);

for (i = 0; i < n; i++)

printf("%i ", test[i]);

return 0;

}

#include <stdio.h>

void print(int data[], int n)
{
     for (int i = 0; i < n; i++)
          printf("%i ", data[i]);
}

int main()
{
	int test[] = {1,2,3,4,5,6,7,8,9};
	int n = sizeof(test)/sizeof(test[0]);
 
     print(test, n);    //vypise vsetky prvky
     print(test, 5);    //vypise prvych 5 prvkov
     print(test + 5, n - 5); //vypise vsetky, okrem prvych 5 prvkov
            
	return 0;
}

#include <stdio.h>

void print(int data[], int n)

{

for (int i = 0; i < n; i++)

printf("%i ", data[i]);

}

int main()

{

int test[] = {1,2,3,4,5,6,7,8,9};

int n = sizeof(test)/sizeof(test[0]);

print(test, n); //vypise vsetky prvky

print(test, 5); //vypise prvych 5 prvkov

print(test + 5, n - 5); //vypise vsetky, okrem prvych 5 prvkov

return 0;

}

#include <stdio.h>

void printb(int *start, int *end)
{
     //porovname, ci start je pred end, *end sa nevypisuje
     while (start < end)  
     {
          //pokym ano, vypisujeme obsah na adrese start 
          printf("%i ", *start); 
          //a posuvame adresu vzdy o 1 int
          start++; 
     }
}

int main()
{
	int test[] = {1,2,3,4,5,6,7,8,9};
	int n = sizeof(test)/sizeof(test[0]);
 
    printb(test, test+n);    //vypise vsetky prvky
    printb(test, test+5);    //vypise prvych 5 prvkov
    printb(test + 5, test+n); //vypise vsetky, okrem prvych 5 prvkov
            
	return 0;
}

#include <stdio.h>

void printb(int *start, int *end)

{

//porovname, ci start je pred end, *end sa nevypisuje

while (start < end)

{

//pokym ano, vypisujeme obsah na adrese start

printf("%i ", *start);

//a posuvame adresu vzdy o 1 int

start++;

}

int main()

{

int test[] = {1,2,3,4,5,6,7,8,9};

int n = sizeof(test)/sizeof(test[0]);

printb(test, test+n); //vypise vsetky prvky

printb(test, test+5); //vypise prvych 5 prvkov

printb(test + 5, test+n); //vypise vsetky, okrem prvych 5 prvkov

return 0;

}

Prednáška 6: znaky [PDF]

Prednáška 6: reťazce [PDF]

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

//vytlaci ASCII kody tlacitelnych znakov
void ascii()
{
	int c = 'a';
	
	//int premenna nepretecie, char ano
    for (c = 0; c < 256; c++)
	{
		if (isprint(c))
			printf("%02x %c\n", c, c); //raz sa chape kod ako cislo, raz ako znak
	}
}

//nacita znaky z riadku a vypise ich skonvertovane na velke pismena
void shout_line()
{
	char c;

	printf("Zadaj riadok: ");
	do
	{
		scanf("%c", &c);
		printf("%c", toupper(c));
	} while (c != '\n');
}

//podobne ako predosle (na male pismena), ale pouzitim getchar/putchar
void lower_line()
{
	int c;
	
	printf("Zadaj riadok: ");
	do
	{
		c = getchar();
		c = tolower(c);
		putchar(c);
	} while (c != '\n');
}

int main()
{
	ascii();
	
	shout_line();
	lower_line();
		
	return 0;
}

#include <stdio.h>

#include <ctype.h>

#include <string.h>

//vytlaci ASCII kody tlacitelnych znakov

void ascii()

{

int c = 'a';

//int premenna nepretecie, char ano

for (c = 0; c < 256; c++)

{

if (isprint(c))

printf("%02x %c\n", c, c); //raz sa chape kod ako cislo, raz ako znak

}

//nacita znaky z riadku a vypise ich skonvertovane na velke pismena

void shout_line()

{

char c;

printf("Zadaj riadok: ");

{

scanf("%c", &c);

printf("%c", toupper(c));

} while (c != '\n');

}

//podobne ako predosle (na male pismena), ale pouzitim getchar/putchar

void lower_line()

{

int c;

printf("Zadaj riadok: ");

{

c = getchar();

c = tolower(c);

putchar(c);

} while (c != '\n');

}

int main()

{

ascii();

shout_line();

lower_line();

return 0;

}

#include <stdio.h>

//vypis vsetkych argumentov programu:
int main(int argc, char* argv[])
{
	int i;
	for (i = 0; i < argc; i++)
	{
		printf("%i: %s\n", i, argv[i]);
	}

	return 0;
}

#include <stdio.h>

//vypis vsetkych argumentov programu:

int main(int argc, char* argv[])

{

int i;

for (i = 0; i < argc; i++)

{

printf("%i: %s\n", i, argv[i]);

}

return 0;

}

#include <stdio.h>

//PRE: minimalne mat miesto na 27 znakov...
void abeceda(char pole[])
{
	int i;
	
	for (i = 0; i < 26; i++)
		pole[i] = 'a'+i;   //naplnime pole abecedou
	pole[26] = '\0';	   // a pridame ukoncovaci znak
}

int main()
{
	//rozne retazce:
	// smernik ukazujuci do pamate skompilovaneho programu
	char *str1 = "abcdefghijklmnopqrstuvwxyz";
	
	//lokalne pole inicializovane znakmi
	char str2[] = "abcdefghijklmnopqrstuvwxyz";
	
	//dalsie lokalne pole
	char pole[100] = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx xxxxxx";

    //aj ked maju rovnaky obsah, tu sa porovnavaju adresy...	
	printf("Zhoda: %i\n", str1==str2);
	//vsimnite si rozne velkosti
	printf("sizeof(str1) = %i\n", sizeof(str1));  //smernik
	printf("sizeof(str2) = %i\n", sizeof(str2));  //pole

	
	//priklad nacitania riadku zo vstupu
	fgets(pole, 100, stdin);

	//priklad nacitania slova zo vstupu
	scanf("%10s", pole);
	
	//priklad naplnenia pola funkciou
	abeceda(pole);
	
	//priklad vypisu retazca: je jedno, ako bol ziskany
	printf("str1 = %s\n", str1);
	printf("str2 = %s\n", str2);
	printf("pole = %s\n", pole);
	
	//v jednom poli moze byt ulozenych viac retazcov...
	printf("pole+27 = %s\n", pole+27);
	
	return 0;
}

#include <stdio.h>

//PRE: minimalne mat miesto na 27 znakov...

void abeceda(char pole[])

{

int i;

for (i = 0; i < 26; i++)

pole[i] = 'a'+i; //naplnime pole abecedou

pole[26] = '\0'; // a pridame ukoncovaci znak

}

int main()

{

//rozne retazce:

// smernik ukazujuci do pamate skompilovaneho programu

char *str1 = "abcdefghijklmnopqrstuvwxyz";

//lokalne pole inicializovane znakmi

char str2[] = "abcdefghijklmnopqrstuvwxyz";

//dalsie lokalne pole

char pole[100] = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx xxxxxx";

//aj ked maju rovnaky obsah, tu sa porovnavaju adresy...

printf("Zhoda: %i\n", str1==str2);

//vsimnite si rozne velkosti

printf("sizeof(str1) = %i\n", sizeof(str1)); //smernik

printf("sizeof(str2) = %i\n", sizeof(str2)); //pole

//priklad nacitania riadku zo vstupu

fgets(pole, 100, stdin);

//priklad nacitania slova zo vstupu

scanf("%10s", pole);

//priklad naplnenia pola funkciou

abeceda(pole);

//priklad vypisu retazca: je jedno, ako bol ziskany

printf("str1 = %s\n", str1);

printf("str2 = %s\n", str2);

printf("pole = %s\n", pole);

//v jednom poli moze byt ulozenych viac retazcov...

printf("pole+27 = %s\n", pole+27);

return 0;

}

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

int checkpwd(const char* pwd)
{
	char sum = 0; 
    do
	{
        //do sumy pridame ASCII hodnotu znaku, kam ukazuje pwd
        //kedze sum je iba 8-bitove so znamienkom, jedna sa o sucet modulo
 		sum += *pwd;

	//casty sposob prechadzania retazca, aj ked nie velmi citatelny, neodporucam
	// pwd++ sa vyhodnoti na adresu ulozenu v pwd, a tato sa posunie
	// potom sa aplikuje *
	// ak bola na starej adrese '\0', vysledok je 0 (nepravda), a cyklus skonci
	} 	while (*pwd++); 
	 
	return !sum;   //heslo je spravne, ak sucet je 0
}

//priklad: vyuzitie funkcie sprintf/sscanf
//skuste najst nejake heslo :) 
int main(int argc, char* argv[])
{
	//pripravime si miesto na druhy argument + nejake int cislo, max 4 cislice, 
	// plus ukoncovaci znak...
	int kapacita = strlen(argv[2]) + 7 + 1;
	char password[kapacita];
	int i, pocet = -1;	

	//z prveho argumentu nacitame pocet
	sscanf(argv[1], "%i", &pocet);
	
	//zistime, ci to bolo OK cislo
	if (pocet < 1 || pocet > 10000000 )
	{
		printf("Prvy parameter mimo rozsah\n");
		return -1;
	}

	for (i = 0; i < pocet; i++)
	{
		sprintf(password, "%s%04i", argv[2], i);
		
		if (checkpwd(password))
			break;
	}
	if (i == pocet)
		printf("Heslo sa nenaslo\n");
	else
		printf("Spravne heslo je: %s\n", password);
	
	return 0;
}

#include <stdio.h>

#include <string.h>

int checkpwd(const char* pwd)

{

char sum = 0;

{

//do sumy pridame ASCII hodnotu znaku, kam ukazuje pwd

//kedze sum je iba 8-bitove so znamienkom, jedna sa o sucet modulo

sum += *pwd;

//casty sposob prechadzania retazca, aj ked nie velmi citatelny, neodporucam

// pwd++ sa vyhodnoti na adresu ulozenu v pwd, a tato sa posunie

// potom sa aplikuje *

// ak bola na starej adrese '\0', vysledok je 0 (nepravda), a cyklus skonci

} while (*pwd++);

return !sum; //heslo je spravne, ak sucet je 0

}

//priklad: vyuzitie funkcie sprintf/sscanf

//skuste najst nejake heslo :)

int main(int argc, char* argv[])

{

//pripravime si miesto na druhy argument + nejake int cislo, max 4 cislice,

// plus ukoncovaci znak...

int kapacita = strlen(argv[2]) + 7 + 1;

char password[kapacita];

int i, pocet = -1;

//z prveho argumentu nacitame pocet

sscanf(argv[1], "%i", &pocet);

//zistime, ci to bolo OK cislo

if (pocet < 1 || pocet > 10000000 )

{

printf("Prvy parameter mimo rozsah\n");

return -1;

}

for (i = 0; i < pocet; i++)

{

sprintf(password, "%s%04i", argv[2], i);

if (checkpwd(password))

break;

}

if (i == pocet)

printf("Heslo sa nenaslo\n");

else

printf("Spravne heslo je: %s\n", password);

return 0;

}

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

//realizacia porovnania retazcov, case insensitive
int compare(char * s1, char * s2)
{
	//v tomto pripade si skonvertujeme znaky na zaciatku oboch retazcov
	// na velke, vysledky porovname
	while (toupper(*s1) == toupper(*s2) && *s1 != '\0')
	{
	//  ak sa zhoduju, a nie je koniec, posunieme zaciatky oboch retazcov
		s1++; s2++;
	}

	//von z cyklu vyskocime v dvoch pripadoch:
	// bud je nezhoda, alebo koniec oboch retazcov
	// ked spravime nasledovny rozdiel, bude nulovy iba ked je koniec oboch
	// cize zhodne(az na velkost pismen) vratia nulu
	// a tie co sa lisia, vratia rozdiel upper verzii ASCII kodov, na mieste, kde sa lisia
	return toupper(*s1) - toupper(*s2);
}

//testovaci kod
// TODO: viete spavit verziu nahradzajucu strncmp?
int main(int argc, char* argv[])
{
	//na regularne porovnanie sa da vyuzit strcmp
	if (strcmp(argv[1], argv[2]) == 0)
	{
		printf("Uplna zhoda\n");		
	}
	else if (compare(argv[1], argv[2]) == 0)
	{
		printf("Zhoda az na velkosti pismen\n");
	}
	else
	{
		printf("Nezhoda\n");
	}

	return 0;
}

#include <stdio.h>

#include <ctype.h>

#include <string.h>

//realizacia porovnania retazcov, case insensitive

int compare(char * s1, char * s2)

{

//v tomto pripade si skonvertujeme znaky na zaciatku oboch retazcov

// na velke, vysledky porovname

while (toupper(*s1) == toupper(*s2) && *s1 != '\0')

{

// ak sa zhoduju, a nie je koniec, posunieme zaciatky oboch retazcov

s1++; s2++;

}

//von z cyklu vyskocime v dvoch pripadoch:

// bud je nezhoda, alebo koniec oboch retazcov

// ked spravime nasledovny rozdiel, bude nulovy iba ked je koniec oboch

// cize zhodne(az na velkost pismen) vratia nulu

// a tie co sa lisia, vratia rozdiel upper verzii ASCII kodov, na mieste, kde sa lisia

return toupper(*s1) - toupper(*s2);

}

//testovaci kod

// TODO: viete spavit verziu nahradzajucu strncmp?

int main(int argc, char* argv[])

{

//na regularne porovnanie sa da vyuzit strcmp

if (strcmp(argv[1], argv[2]) == 0)

{

printf("Uplna zhoda\n");

}

else if (compare(argv[1], argv[2]) == 0)

{

printf("Zhoda az na velkosti pismen\n");

}

else

{

printf("Nezhoda\n");

}

return 0;

}

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

//funkcia, ktora vlozi jeden retazec do druheho
// what: co sa vlozi
// to: do coho sa to vlozi
// where: na aky index sa to vlozi
// vrati: povodnu adresu to, aby sa dala pouzit napr. vo vypise
char* insert(char* to, char* what, int where)
{
	//najprv si osetrime pripadne nelegalne pozicie
	if (where < 0)
		where = 0;
	if (where > strlen(to))
		where = strlen(to);
	
	//najprv si spravime miesto, presunieme cast retazca z
	//   to+where  po koniec (aj vratane '\0', preto +1)
	//   na to+where+strlen(what) -> tu nerezervujeme miesto na '\0', 
	//   lebo vysledok ma byt suvisly
	memmove(to+where+strlen(what), to+where, strlen(to)-where+1);
	//do vytvoreneho miesta presunieme bajty z what, okrem '\0'
	memmove(to+where, what, strlen(what));
	
	//vraciame adresu, ktoru sme dostali
	// nie je to potrebne, kedze sme pracovali s odkazmi
	// ale ulahcuje to pouzivanie funkcie, vid main
	return to;
}

//testovaci kod
int main(int argc, char* argv[])
{
	//pouzijeme command line argumenty na vstup
	char * s1 = argv[1];
	char * s2 = argv[2];
	int ix = atoi (argv[3]);
	//musime mat rezervovanu dostatocnu pamat
	char buffer[strlen(s1)+strlen(s2)+1];
	
	//vyuzijeme strcpy na inicializaciu buffera
	strcpy(buffer, s1);

	//vdaka return z funkcie insert, mozeme vysledok poslat rovno scanf-u
	// nie vzdy je to ale dobry napad, hlavne ak vysledok moze byt chybovy NULL pointer
	printf("%s\n", insert(buffer, s2, ix));  

	return 0;
}

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

//funkcia, ktora vlozi jeden retazec do druheho

// what: co sa vlozi

// to: do coho sa to vlozi

// where: na aky index sa to vlozi

// vrati: povodnu adresu to, aby sa dala pouzit napr. vo vypise

char* insert(char* to, char* what, int where)

{

//najprv si osetrime pripadne nelegalne pozicie

if (where < 0)

where = 0;

if (where > strlen(to))

where = strlen(to);

//najprv si spravime miesto, presunieme cast retazca z

// to+where po koniec (aj vratane '\0', preto +1)

// na to+where+strlen(what) -> tu nerezervujeme miesto na '\0',

// lebo vysledok ma byt suvisly

memmove(to+where+strlen(what), to+where, strlen(to)-where+1);

//do vytvoreneho miesta presunieme bajty z what, okrem '\0'

memmove(to+where, what, strlen(what));

//vraciame adresu, ktoru sme dostali

// nie je to potrebne, kedze sme pracovali s odkazmi

// ale ulahcuje to pouzivanie funkcie, vid main

return to;

}

//testovaci kod

int main(int argc, char* argv[])

{

//pouzijeme command line argumenty na vstup

char * s1 = argv[1];

char * s2 = argv[2];

int ix = atoi (argv[3]);

//musime mat rezervovanu dostatocnu pamat

char buffer[strlen(s1)+strlen(s2)+1];

//vyuzijeme strcpy na inicializaciu buffera

strcpy(buffer, s1);

//vdaka return z funkcie insert, mozeme vysledok poslat rovno scanf-u

// nie vzdy je to ale dobry napad, hlavne ak vysledok moze byt chybovy NULL pointer

printf("%s\n", insert(buffer, s2, ix));

return 0;

}

Prednáška 7 [PDF]

/*************************************************************
 * K prednaske 7, demonstracia roznych druhov alokacie pamati
 */

#include 
#include 

//bude sa pouzivat ako limit na velkost pamate
#define MAXLEN 10000u   //u ako unsigned int

//Priklady vhodnych globalnych premennych
// globalne su, lebo ich mozeme pouzivat na viacerych miestach
// dame ich tiez const, kedze sa maju len citat
// a zvyraznime ich specialnost cez UPPERCASE konvenciu
const char * SAMOHLASKY = "aeiouy";
const char * SPOLUHLASKY = "bcdfghjklmnprstvz";
const int LENSAMO = 6;
const int LENSPOLU = 17;


//verzia funkcie vyuzivajuca pamat automaticku
// v tomto pripade miesto dostatocne velkosti 
// musi vytvorit (a pripadne uvolnit) volajuca funkcia
// funkcia vracia odkaz na vytvoreny retazec (adresu)
char* generuj1(char buffer[], unsigned int len)
{
    unsigned int i;
    //POZN.: KVOLI BEZPECNOSTI davam len ako unsigned int
    // - keby bolo len zaporne, kod by nefungoval spravne:
    //    priklaz buffer[len] by zapisal pred alokovanu pamat
    
    //v cykle vzdy nastavime 2 znaky v jednom behu
    // ak len == 2: i = 0, nastavime 2 znaky, cyklus skonci
    // ak len == 1: i = 0, nastavime 2 znaky, cyklus skonci
    for (i = 0; i < len; i+=2)
    {
        //pozn.: potencialne mozeme vygenerovat o 1 viac znakov
        // ale ak je samohlaska navyse, prepise sa za cyklom na '\0'
        buffer[i] = SPOLUHLASKY[rand()%LENSPOLU];
        buffer[i+1] = SAMOHLASKY[rand()%LENSAMO];
    }
    //ak bolo len parne, mame kolko znakov treba, posledny na [len-1]
    //   - doplnime uzavretie retazca:
    //ak bolo len neparne, mame o 1 znak viac, posledny na [len]
    //   - ten sa skoriguje uzavretim retazca:
    buffer[len] = '\0';
    
    //teoreticky toto nie je nutne, ale moze byt pouzite vo volajucej
    // funkcii, napr. printf("%s\n", generuj1(buffer, 10)); 
    return buffer;
}

//Sposob pouzitia generuj1:
void test1a(unsigned int len)
{
    //pre generuj1 sa musime starat o pamat my
    
    //vieme pouzit pamat automaticku variabilnej dlzky
    // (ale nesmie byt len privelke, v zavislosti na prekladaci)
    char buffer[len+1];
    
    //vysledok je garantovany, nemusime sa o neho starat
    // posleme ho rovno na vypis
    printf("\nTest1a: %s\n", generuj1(buffer, len));
 
    //pri skonceni funkcie sa buffer uvolni automaticky
}

//Sposob pouzitia generuj1:
void test1b(unsigned int len)
{
    // mozeme pouzit aj pamat dynamicku:
    char *buffer;       //pripravime si len pointer
    
    //pamat si vyziadame od systemu podla len
    buffer = (char*) malloc((len+1)*sizeof(char));
    //musime ale skontrolovat, ci je dost pamate
    if (buffer != NULL)
    {
        //vysledok je garantovany, nemusime sa o neho starat
        // posleme ho rovno na vypis
        printf("\nTest1b: %s\n", generuj1(buffer, len));
        
        //kedze sme mali dynamicku pamat, ktoru uz nepotrebujeme, uvolnime ju
        free(buffer);
    }
    //free(buffer) je vnutri if, ak sa nepodarilo alokovat, nemame co uvolnit
}


//POZOR: ZLA VERZIA FUNKCIE, TAKTO SA TO NEMA POUZIVAT!
char* generuj2(unsigned int len)
{
    unsigned int i;
    //automaticka alokacia, pole variabilnej dlzky (C99 standard)
    char buffer[len+1];
    
    for (i = 0; i < len; i+=2) { buffer[i] = SPOLUHLASKY[rand()%LENSPOLU]; buffer[i+1] = SAMOHLASKY[rand()%LENSAMO]; } buffer[len] = '\0'; //TOTO JE VELMI NEBEZPECNA CHYBA // -co sa stane: posle sa odkaz na pamat buffer, ktora // po return prestane byt alokovana // -problem je: obcas to moze fungovat: ked sa nevola dalsia funkcia, // data zostanu v pamati // -ked sa vsak vola dalsia funkcia (napr. printf), buffer sa prepise // udajmi tejto novej funkcie return buffer; } //Ukazka problemov s generuj2 void test2(unsigned int len) { //pre generuj2 sa o pamat zdanlivo nemusime starat //ak date dost velku len, vysledok sa zobrazi "poskodeny" printf("\nTest2: %s\n", generuj2(len)); } //Funkcia so statickou pamatou (podobne, keby buffer bola globalna premenna) //Funkcia ma svoju pamat, vytvara retazec v nej, volajuca funkcia // sa o nic nemusi starat //PROBLEM: buffer existuje len jeden: // - neda sa pouzit paralelne, // - pri druhom volani sa prepise starsia hodnota //PROBLEM2: staticke pole ma fixnu dlzku, musime kontrolovat, ci nepretecie char* generuj3(unsigned int len) { unsigned int i; //staticka alokacia, pole musi mat fixnu dlzku static char buffer[MAXLEN+1]; //ak je vstupny parameter prilis velky, nemozeme splnit ulohu // vratime neplatnu adresu NULL ako chybu if (len > MAXLEN)
       return NULL;
    
    for (i = 0; i < len; i+=2)
    {
        buffer[i] = SPOLUHLASKY[rand()%LENSPOLU];
        buffer[i+1] = SAMOHLASKY[rand()%LENSAMO];
    }
    buffer[len] = '\0';
    
    //tato funkcia vlastne vracia vzdy tu istu adresu:
    return buffer;
}

//Ukazka problemov s generuj3
void test3(unsigned int len)
{
    //pre generuj3 sa opat o pamat zdanlivo nemusime starat
    // ale budeme chciet teraz 2 retazce, takze si pripravime 2 smerniky 
    // na ulozenie vystupnej adresy z generuj3
    char *str1, *str2;
     
    str1 = generuj3(len);  //ulozime si vysledok pre dalsie pouzitie
    if (str1 != NULL)                //kontrola...
       printf("\nTest3, str1 (%p) %s\n", str1, str1);
       //poznamka: %p nam vypise adresu, nie retazec, na kontrolu
       
    str2 = generuj3(len);  //dame si dalsi retazec
    if (str2 != NULL)                //kontrola...
        printf("\nTest3, str2 (%p) %s\n", str2, str2);
        
    //a pozrieme sa naspat na str1:
    if (str1 != NULL)                
        printf("\nTest3, str1 (%p) %s\n", str1, str1);

}


//Funkcia s dynamickou pamatou, funkcia vygeneruje nove pole podla poziadavky
//POZOR: volajuca funkcia sa musi postarat o uvolnenie pamate
//  - ak to nespravi, dochadza k postupnemu vycerpavaniu pamate, memory leak
//  (zial casty problem aj niektorych komercnych programov a hier)
char* generuj4(unsigned int len)
{
    unsigned int i;
    //tu si vytvorime len pointer, kde si neskor ulozime adresu 
    //  novo pridelenej pamate
    char *buffer;

    //dame si pridelit novu pamat od systemu, 
    // potrebujeme pamat, kde sa zmesti len+1 znakov (char)
    // ziskanu adresu ulozime do smernika buffer
    buffer = (char*) malloc( (len+1)*sizeof(char) );
    
    //ak nie je dost pamate, malloc vrati neplatnu adresu NULL 
    // v tomto pripade ju posunieme volajucej funkcii na osetrenie   
    if (buffer == NULL)
       return buffer;
    
    //tu mame platne pole, postupujeme ako predtym
    for (i = 0; i < len; i+=2)
    {
        buffer[i] = SPOLUHLASKY[rand()%LENSPOLU];
        buffer[i+1] = SAMOHLASKY[rand()%LENSAMO];
    }
    buffer[len] = '\0';
    
    //tato funkcia vracia adresu pridelenu cez malloc, 
    // ktoru si pamatame v premennej buffer
    return buffer;
}

//Ukazka pouzitia generuj4
void test4a(unsigned int len)
{
    //pouzijeme podobny kod ako pre generuj4
    //pre generuj3 sa opat o pamat zdanlivo nemusime starat
    // ale budeme chciet teraz 2 retazce, takze si pripravime 2 smerniky 
    // na ulozenie vystupnej adresy z generuj3
    char *str1, *str2;
    
    str1 = generuj4(len);  //ulozime si vysledok pre dalsie pouzitie
    if (str1 != NULL)                //kontrola...
       printf("\nTest4a, str1 (%p) %s\n", str1, str1);

    str2 = generuj4(len);  //dame si dalsi retazec
    if (str2 != NULL)                //kontrola...
        printf("\nTest4a, str2 (%p) %s\n", str2, str2);
        
    //a pozrieme sa naspat na str1:
    if (str1 != NULL)                
        printf("\nTest4a, str1  (%p) %s\n", str1, str1);

    //po skonceni prace s dynamickymi retazcami musime pamat uvolnit rucne
    // (vid test4b co sa stane, ked nie)
    //retazce uvolni ta funkcia, ktora vie, ze sa uz dalej nebudu pouzivat
    free(str1);
    free(str2);
}

//POZOR: Ukazka zleho pouzitia generuj4, memory leak
// POZOR, POZOR: moze sposobit pad systemu a zle veci...
void test4b(unsigned int len)
{
    char *str;
    int count = 0;
    
    while (1)
    {
        str = generuj4(len);
        if (str == NULL)
           break;
           
        //pre zrychlenie efektu som zakomentoval vypis
        //printf("%s\n", str);
        count++;
        
        //pre spravne pouzitie by tu malo byt:
        //free(str);
        
        // odkomentujte, ked vyskusate nespravnu verziu, 
        //  a porovnajte spotrebu pamate cez task manager
    }
    //sem sa na modernych strojoch zvacsa nedostanete, zavisi na nastaveni
    // swap pamate a OS
    printf("Vygenerovalo sa %i retazcov:", count);
}


int main()
{
    unsigned int len;
    
    printf("Zadaj velkost: ");
    scanf("%u", &len);

    test1a(len);
    test1b(len);
    test2(len);
    test3(len);
    test4a(len);
    //POZOR: odkomentujte len ak to chcete risknut... :)
    //pred spustenim: zapnite si task manager a usporiadajte podla pamate
    //Dajte velke len, a sledujte pamat, 
    // pripravte sa  zavriet program cez task manager
    //test4b(len);
    
    return 0;  
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

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

* K prednaske 7, demonstracia roznych druhov alokacie pamati

#include

//bude sa pouzivat ako limit na velkost pamate

#define MAXLEN 10000u //u ako unsigned int

//Priklady vhodnych globalnych premennych

// globalne su, lebo ich mozeme pouzivat na viacerych miestach

// dame ich tiez const, kedze sa maju len citat

// a zvyraznime ich specialnost cez UPPERCASE konvenciu

const char * SAMOHLASKY = "aeiouy";

const char * SPOLUHLASKY = "bcdfghjklmnprstvz";

const int LENSAMO = 6;

const int LENSPOLU = 17;

//verzia funkcie vyuzivajuca pamat automaticku

// v tomto pripade miesto dostatocne velkosti

// musi vytvorit (a pripadne uvolnit) volajuca funkcia

// funkcia vracia odkaz na vytvoreny retazec (adresu)

char* generuj1(char buffer[], unsigned int len)

{

unsigned int i;

//POZN.: KVOLI BEZPECNOSTI davam len ako unsigned int

// - keby bolo len zaporne, kod by nefungoval spravne:

// priklaz buffer[len] by zapisal pred alokovanu pamat

//v cykle vzdy nastavime 2 znaky v jednom behu

// ak len == 2: i = 0, nastavime 2 znaky, cyklus skonci

// ak len == 1: i = 0, nastavime 2 znaky, cyklus skonci

for (i = 0; i < len; i+=2)

{

//pozn.: potencialne mozeme vygenerovat o 1 viac znakov

// ale ak je samohlaska navyse, prepise sa za cyklom na '\0'

buffer[i] = SPOLUHLASKY[rand()%LENSPOLU];

buffer[i+1] = SAMOHLASKY[rand()%LENSAMO];

}

//ak bolo len parne, mame kolko znakov treba, posledny na [len-1]

// - doplnime uzavretie retazca:

//ak bolo len neparne, mame o 1 znak viac, posledny na [len]

// - ten sa skoriguje uzavretim retazca:

buffer[len] = '\0';

//teoreticky toto nie je nutne, ale moze byt pouzite vo volajucej

// funkcii, napr. printf("%s\n", generuj1(buffer, 10));

return buffer;

}

//Sposob pouzitia generuj1:

void test1a(unsigned int len)

{

//pre generuj1 sa musime starat o pamat my

//vieme pouzit pamat automaticku variabilnej dlzky

// (ale nesmie byt len privelke, v zavislosti na prekladaci)

char buffer[len+1];

//vysledok je garantovany, nemusime sa o neho starat

// posleme ho rovno na vypis

printf("\nTest1a: %s\n", generuj1(buffer, len));

//pri skonceni funkcie sa buffer uvolni automaticky

}

//Sposob pouzitia generuj1:

void test1b(unsigned int len)

{

// mozeme pouzit aj pamat dynamicku:

char *buffer; //pripravime si len pointer

//pamat si vyziadame od systemu podla len

buffer = (char*) malloc((len+1)*sizeof(char));

//musime ale skontrolovat, ci je dost pamate

if (buffer != NULL)

{

//vysledok je garantovany, nemusime sa o neho starat

// posleme ho rovno na vypis

printf("\nTest1b: %s\n", generuj1(buffer, len));

//kedze sme mali dynamicku pamat, ktoru uz nepotrebujeme, uvolnime ju

free(buffer);

}

//free(buffer) je vnutri if, ak sa nepodarilo alokovat, nemame co uvolnit

}

//POZOR: ZLA VERZIA FUNKCIE, TAKTO SA TO NEMA POUZIVAT!

char* generuj2(unsigned int len)

{

unsigned int i;

//automaticka alokacia, pole variabilnej dlzky (C99 standard)

char buffer[len+1];

for (i = 0; i < len; i+=2) { buffer[i] = SPOLUHLASKY[rand()%LENSPOLU]; buffer[i+1] = SAMOHLASKY[rand()%LENSAMO]; } buffer[len] = '\0'; //TOTO JE VELMI NEBEZPECNA CHYBA // -co sa stane: posle sa odkaz na pamat buffer, ktora // po return prestane byt alokovana // -problem je: obcas to moze fungovat: ked sa nevola dalsia funkcia, // data zostanu v pamati // -ked sa vsak vola dalsia funkcia (napr. printf), buffer sa prepise // udajmi tejto novej funkcie return buffer; } //Ukazka problemov s generuj2 void test2(unsigned int len) { //pre generuj2 sa o pamat zdanlivo nemusime starat //ak date dost velku len, vysledok sa zobrazi "poskodeny" printf("\nTest2: %s\n", generuj2(len)); } //Funkcia so statickou pamatou (podobne, keby buffer bola globalna premenna) //Funkcia ma svoju pamat, vytvara retazec v nej, volajuca funkcia // sa o nic nemusi starat //PROBLEM: buffer existuje len jeden: // - neda sa pouzit paralelne, // - pri druhom volani sa prepise starsia hodnota //PROBLEM2: staticke pole ma fixnu dlzku, musime kontrolovat, ci nepretecie char* generuj3(unsigned int len) { unsigned int i; //staticka alokacia, pole musi mat fixnu dlzku static char buffer[MAXLEN+1]; //ak je vstupny parameter prilis velky, nemozeme splnit ulohu // vratime neplatnu adresu NULL ako chybu if (len > MAXLEN)

return NULL;

for (i = 0; i < len; i+=2)

{

buffer[i] = SPOLUHLASKY[rand()%LENSPOLU];

buffer[i+1] = SAMOHLASKY[rand()%LENSAMO];

}

buffer[len] = '\0';

//tato funkcia vlastne vracia vzdy tu istu adresu:

return buffer;

}

//Ukazka problemov s generuj3

void test3(unsigned int len)

{

//pre generuj3 sa opat o pamat zdanlivo nemusime starat

// ale budeme chciet teraz 2 retazce, takze si pripravime 2 smerniky

// na ulozenie vystupnej adresy z generuj3

char *str1, *str2;

str1 = generuj3(len); //ulozime si vysledok pre dalsie pouzitie

if (str1 != NULL) //kontrola...

printf("\nTest3, str1 (%p) %s\n", str1, str1);

//poznamka: %p nam vypise adresu, nie retazec, na kontrolu

str2 = generuj3(len); //dame si dalsi retazec

if (str2 != NULL) //kontrola...

printf("\nTest3, str2 (%p) %s\n", str2, str2);

//a pozrieme sa naspat na str1:

if (str1 != NULL)

printf("\nTest3, str1 (%p) %s\n", str1, str1);

}

//Funkcia s dynamickou pamatou, funkcia vygeneruje nove pole podla poziadavky

//POZOR: volajuca funkcia sa musi postarat o uvolnenie pamate

// - ak to nespravi, dochadza k postupnemu vycerpavaniu pamate, memory leak

// (zial casty problem aj niektorych komercnych programov a hier)

char* generuj4(unsigned int len)

{

unsigned int i;

//tu si vytvorime len pointer, kde si neskor ulozime adresu

// novo pridelenej pamate

char *buffer;

//dame si pridelit novu pamat od systemu,

// potrebujeme pamat, kde sa zmesti len+1 znakov (char)

// ziskanu adresu ulozime do smernika buffer

buffer = (char*) malloc( (len+1)*sizeof(char) );

//ak nie je dost pamate, malloc vrati neplatnu adresu NULL

// v tomto pripade ju posunieme volajucej funkcii na osetrenie

if (buffer == NULL)

return buffer;

//tu mame platne pole, postupujeme ako predtym

for (i = 0; i < len; i+=2)

{

buffer[i] = SPOLUHLASKY[rand()%LENSPOLU];

buffer[i+1] = SAMOHLASKY[rand()%LENSAMO];

}

buffer[len] = '\0';

//tato funkcia vracia adresu pridelenu cez malloc,

// ktoru si pamatame v premennej buffer

return buffer;

}

//Ukazka pouzitia generuj4

void test4a(unsigned int len)

{

//pouzijeme podobny kod ako pre generuj4

//pre generuj3 sa opat o pamat zdanlivo nemusime starat

// ale budeme chciet teraz 2 retazce, takze si pripravime 2 smerniky

// na ulozenie vystupnej adresy z generuj3

char *str1, *str2;

str1 = generuj4(len); //ulozime si vysledok pre dalsie pouzitie

if (str1 != NULL) //kontrola...

printf("\nTest4a, str1 (%p) %s\n", str1, str1);

str2 = generuj4(len); //dame si dalsi retazec

if (str2 != NULL) //kontrola...

printf("\nTest4a, str2 (%p) %s\n", str2, str2);

//a pozrieme sa naspat na str1:

if (str1 != NULL)

printf("\nTest4a, str1 (%p) %s\n", str1, str1);

//po skonceni prace s dynamickymi retazcami musime pamat uvolnit rucne

// (vid test4b co sa stane, ked nie)

//retazce uvolni ta funkcia, ktora vie, ze sa uz dalej nebudu pouzivat

free(str1);

free(str2);

}

//POZOR: Ukazka zleho pouzitia generuj4, memory leak

// POZOR, POZOR: moze sposobit pad systemu a zle veci...

void test4b(unsigned int len)

{

char *str;

int count = 0;

while (1)

{

str = generuj4(len);

if (str == NULL)

break;

//pre zrychlenie efektu som zakomentoval vypis

//printf("%s\n", str);

count++;

//pre spravne pouzitie by tu malo byt:

//free(str);

// odkomentujte, ked vyskusate nespravnu verziu,

// a porovnajte spotrebu pamate cez task manager

}

//sem sa na modernych strojoch zvacsa nedostanete, zavisi na nastaveni

// swap pamate a OS

printf("Vygenerovalo sa %i retazcov:", count);

}

int main()

{

unsigned int len;

printf("Zadaj velkost: ");

scanf("%u", &len);

test1a(len);

test1b(len);

test2(len);

test3(len);

test4a(len);

//POZOR: odkomentujte len ak to chcete risknut... :)

//pred spustenim: zapnite si task manager a usporiadajte podla pamate

//Dajte velke len, a sledujte pamat,

// pripravte sa zavriet program cez task manager

//test4b(len);

return 0;

}

#include <stdio.h>

/*************************************************************
 * K prednaske 7, demonstracia realloc na natahovatelne pole
 */

#include 
#include 

//v tejto funkcii dostaneme na vstup pole a jeho dlzku, 
// do pola pridame jeden novy prvok zo vstupu na koniec a upravime dlzku
// vyuzivame odovzdavanie odkazom: 
//  dostaneme adresy premennych, ktore sa budu menit 
// funkcia vrati nacitanu hodnotu, alebo 0 ak sa nenacita nic
int nacitaj( int ** pZoznam, int * pDlzka )
// vsimnite si: pZoznam je pointer na pointer na int, pDlzka je pointer na int
{
    int tmp;
    //pomocone premenne, realne nie su potrebne, 
    //  ale kvoli citatelnosti prikladu ich pouzijem
    int novaDlzka;
    int *staryZoznam, *novyZoznam;
    
    //1. pokusime sa nacitat platne cislo
    if (scanf("%d", &tmp) < 1)
       return 0;    //chybovy stav, da sa zistit aj tak, ze sa nezmeni dlzka
       
    //potrebujeme pridat cislo, zvacsime velkost alokovanej pamate
    
    novaDlzka   = *pDlzka + 1;        
    //precitali sme dlzku na adrese ulozenej v pointeri pDlzka, a zvacsili o 1
    staryZoznam = *pZoznam;
    //pZoznam je pointer na pointer, precitame adresu na mieste, 
    // kam pZoznam ukazuje, a ulozime adresu do pointera staryZoznam
    
    novyZoznam  = (int*) realloc(staryZoznam, novaDlzka * sizeof(int));   
    //do realloc sme dali staru adresu dynamickeho pola a novu dlzku, ktoru chceme
    // mozete si porovnat, ci sa adresa zmenila, alebo zostala povodna
    // pomocou (novyZoznam == staryZoznam)
    
    //ked uz mame novu dlzku, a novu adresu zaciatku, mozeme ich ulozit do main
    // premennych cez vstupne pointery:
    *pDlzka     = novaDlzka;
    *pZoznam    = novyZoznam;
    
    //predosle sa dalo spravit cez neprehladny zapis: 
    //*pZoznam = (int*) realloc(*pZoznam, ++*pDlzka * sizeof(int));
    
    //do noveho zoznamu pridame na koniec nacitane cislo:
    novyZoznam[novaDlzka-1] = tmp;
    //pozn.: zmeni sa obsah, kam ukazuje novyZoznam, ale zaroven aj obsah, kam 
    //       ukazuje zoznam v main, kedze ukazuju na to iste miesto 
    //       (vdaka prikazu *pZoznam = novyZoznam, kedze pZoznam = &zoznam)
       
    return tmp;   
}

//POZNAMKA: funkcia nacitaj je velmi neefektivna
// dynamicky zoznam je lepsie robit cez struktury, kde sa uklada aj kapacita
// (napr., zmesti sa 1000 prvkov, pouzivame 153 z nich)
// a realloc sa vola len ked sa vycerpa kapacita, pricom ju zvacsi naraz 
//  o viac miest (napr. na dvojnasobok)

//TODO: podobne ako pridavat, zo zoznamu by sme vedeli prvky odoberat a zoznam
// prislusne skratit
// POZOR: keby ste chceli odobrat prvok na zaciatku/v strede zoznamu 
//  (podobne vlozit), bolo by potrebne ostatne prvky poposuvat, az potom realloc
//  (pri vkladani najprv realloc) 

int main()
{
    //budeme pouzivat zoznam cisel a jeho dlzku
    // inicializujeme zoznam neplatnou adresou NULL,
    // a dlzka je 0, kedze nemame cisla
    int *zoznam = NULL;
    int dlzka = 0;
    
    //v nacitaj sa bude menit obsah premennej zoznam aj dlzka
    // preto tam posielame adresy tychto premennych, nie ich obsah
    while (nacitaj(&zoznam, &dlzka) != 0)
    {
        printf("Zatial mame %i prvkov, posledny je: %i\n",
                       dlzka, zoznam[dlzka-1]);
    }
    
    //TODO: co chceme dalej so zoznamom...
    
    //ak uz zoznam nepotrebujeme, uvolnime pamat
    // pamat sa da uvolnit cez free(zoznam), ale aj cez realloc:
    dlzka = 0;
    zoznam = (int*) realloc(zoznam, dlzka);
    
    //realloc je lepsi, lebo tymto volanim nastavime zoznam na NULL,
    // a mohli by sme ho znovu pouzit ako prazdny
    
    return 0;  
}

#include <stdio.h>

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

* K prednaske 7, demonstracia realloc na natahovatelne pole

#include

//v tejto funkcii dostaneme na vstup pole a jeho dlzku,

// do pola pridame jeden novy prvok zo vstupu na koniec a upravime dlzku

// vyuzivame odovzdavanie odkazom:

// dostaneme adresy premennych, ktore sa budu menit

// funkcia vrati nacitanu hodnotu, alebo 0 ak sa nenacita nic

int nacitaj( int ** pZoznam, int * pDlzka )

// vsimnite si: pZoznam je pointer na pointer na int, pDlzka je pointer na int

{

int tmp;

//pomocone premenne, realne nie su potrebne,

// ale kvoli citatelnosti prikladu ich pouzijem

int novaDlzka;

int *staryZoznam, *novyZoznam;

//1. pokusime sa nacitat platne cislo

if (scanf("%d", &tmp) < 1)

return 0; //chybovy stav, da sa zistit aj tak, ze sa nezmeni dlzka

//potrebujeme pridat cislo, zvacsime velkost alokovanej pamate

novaDlzka = *pDlzka + 1;

//precitali sme dlzku na adrese ulozenej v pointeri pDlzka, a zvacsili o 1

staryZoznam = *pZoznam;

//pZoznam je pointer na pointer, precitame adresu na mieste,

// kam pZoznam ukazuje, a ulozime adresu do pointera staryZoznam

novyZoznam = (int*) realloc(staryZoznam, novaDlzka * sizeof(int));

//do realloc sme dali staru adresu dynamickeho pola a novu dlzku, ktoru chceme

// mozete si porovnat, ci sa adresa zmenila, alebo zostala povodna

// pomocou (novyZoznam == staryZoznam)

//ked uz mame novu dlzku, a novu adresu zaciatku, mozeme ich ulozit do main

// premennych cez vstupne pointery:

*pDlzka = novaDlzka;

*pZoznam = novyZoznam;

//predosle sa dalo spravit cez neprehladny zapis:

//*pZoznam = (int*) realloc(*pZoznam, ++*pDlzka * sizeof(int));

//do noveho zoznamu pridame na koniec nacitane cislo:

novyZoznam[novaDlzka-1] = tmp;

//pozn.: zmeni sa obsah, kam ukazuje novyZoznam, ale zaroven aj obsah, kam

// ukazuje zoznam v main, kedze ukazuju na to iste miesto

// (vdaka prikazu *pZoznam = novyZoznam, kedze pZoznam = &zoznam)

return tmp;

}

//POZNAMKA: funkcia nacitaj je velmi neefektivna

// dynamicky zoznam je lepsie robit cez struktury, kde sa uklada aj kapacita

// (napr., zmesti sa 1000 prvkov, pouzivame 153 z nich)

// a realloc sa vola len ked sa vycerpa kapacita, pricom ju zvacsi naraz

// o viac miest (napr. na dvojnasobok)

//TODO: podobne ako pridavat, zo zoznamu by sme vedeli prvky odoberat a zoznam

// prislusne skratit

// POZOR: keby ste chceli odobrat prvok na zaciatku/v strede zoznamu

// (podobne vlozit), bolo by potrebne ostatne prvky poposuvat, az potom realloc

// (pri vkladani najprv realloc)

int main()

{

//budeme pouzivat zoznam cisel a jeho dlzku

// inicializujeme zoznam neplatnou adresou NULL,

// a dlzka je 0, kedze nemame cisla

int *zoznam = NULL;

int dlzka = 0;

//v nacitaj sa bude menit obsah premennej zoznam aj dlzka

// preto tam posielame adresy tychto premennych, nie ich obsah

while (nacitaj(&zoznam, &dlzka) != 0)

{

printf("Zatial mame %i prvkov, posledny je: %i\n",

dlzka, zoznam[dlzka-1]);

}

//TODO: co chceme dalej so zoznamom...

//ak uz zoznam nepotrebujeme, uvolnime pamat

// pamat sa da uvolnit cez free(zoznam), ale aj cez realloc:

dlzka = 0;

zoznam = (int*) realloc(zoznam, dlzka);

//realloc je lepsi, lebo tymto volanim nastavime zoznam na NULL,

// a mohli by sme ho znovu pouzit ako prazdny

return 0;

}

Prednáška 8 [PDF]

#include 
#include 
#include 
#include 

/// Definicie typov

/// Zlozky GPS suradnic
typedef double gps_ns;
typedef double gps_ew;

/// GPS suradnice
typedef struct _gps { gps_ns lat; gps_ew lon; } GPS;

/// Lokalita, spaja nazov so suradnicami
typedef struct _lokalita { 
   char nazov[31];
   GPS gps; 
} Lokalita;

//Funkcia na vypis lokality
//vstupom je lokalita, formatovane ju vypise
void vypis_lokalitu(Lokalita lokalita) {
	printf("%s ma suradnice %.5lf %.5lf\n",
		lokalita.nazov,
		lokalita.gps.lat,
		lokalita.gps.lon);
}

//Funkcia vrati nahodnu GPS suradnicu
GPS random_gps() {
	//docasna premenna, zije v tejto funkcii iba po return
	GPS gps;   

	//vypocty robime priamo na zlozkach docasnej premennej
    gps.lat = -90.0 + 180.0 * rand()/(double)RAND_MAX;
	gps.lon = -180.0 + 360.0 * rand()/(double)RAND_MAX;

	//tu nastane magia: prekladac to prepoji s volajucou funkciou
     // a nakopiruje docasne gps kam treba
	return gps;
}
int main() {
	Lokalita test;                   //nema definovany obsah                     
    GPS gps1 = {48.14816, 17.10674}; //suradnice Bratislavy
    Lokalita ba;                     //nenastavena, nastavime rucne

    srand(time(0));   //random init...

    ba.gps = gps1;   
    //ba.gps spristupni polozku gps z premennej ba
    // operator = skopiruje cely obsah premennej gps1 do ba.gps

    strcpy(ba.nazov, "Bratislava");
    //ba.nazov je standardne pole znakov, cize s nim pracujeme, 
    // ako s beznym miestom na retazec,
    // vratane toho, ze moze dojst k preteceniu, ak si nedame pozor 
    vypis_lokalitu(ba);

	strcpy(test.nazov, "Random");
	        //naplni sa gps suradnica podla vysledku funkcie
	test.gps = random_gps();	
    vypis_lokalitu(test);
    
    return 0;
}

#include

/// Definicie typov

/// Zlozky GPS suradnic

typedef double gps_ns;

typedef double gps_ew;

/// GPS suradnice

typedef struct _gps { gps_ns lat; gps_ew lon; } GPS;

/// Lokalita, spaja nazov so suradnicami

typedef struct _lokalita {

char nazov[31];

GPS gps;

} Lokalita;

//Funkcia na vypis lokality

//vstupom je lokalita, formatovane ju vypise

void vypis_lokalitu(Lokalita lokalita) {

printf("%s ma suradnice %.5lf %.5lf\n",

lokalita.nazov,

lokalita.gps.lat,

lokalita.gps.lon);

}

//Funkcia vrati nahodnu GPS suradnicu

GPS random_gps() {

//docasna premenna, zije v tejto funkcii iba po return

GPS gps;

//vypocty robime priamo na zlozkach docasnej premennej

gps.lat = -90.0 + 180.0 * rand()/(double)RAND_MAX;

gps.lon = -180.0 + 360.0 * rand()/(double)RAND_MAX;

//tu nastane magia: prekladac to prepoji s volajucou funkciou

// a nakopiruje docasne gps kam treba

return gps;

}

int main() {

Lokalita test; //nema definovany obsah

GPS gps1 = {48.14816, 17.10674}; //suradnice Bratislavy

Lokalita ba; //nenastavena, nastavime rucne

srand(time(0)); //random init...

ba.gps = gps1;

//ba.gps spristupni polozku gps z premennej ba

// operator = skopiruje cely obsah premennej gps1 do ba.gps

strcpy(ba.nazov, "Bratislava");

//ba.nazov je standardne pole znakov, cize s nim pracujeme,

// ako s beznym miestom na retazec,

// vratane toho, ze moze dojst k preteceniu, ak si nedame pozor

vypis_lokalitu(ba);

strcpy(test.nazov, "Random");

//naplni sa gps suradnica podla vysledku funkcie

test.gps = random_gps();

vypis_lokalitu(test);

return 0;

}

#include 
#include 
#include 

/// Definicie typov

/// Zlozky GPS suradnic
typedef double gps_ns;
typedef double gps_ew;

/// GPS suradnice
typedef struct _gps { gps_ns lat; gps_ew lon; } GPS;

/// Lokalita, spaja nazov so suradnicami
typedef struct _lokalita { 
   char nazov[31];
   GPS gps; 
} Lokalita;

//chceme nacitat gps suradnicu z klavesnice cez scanf
// vstupom je adresa struktury, kam sa suradnica ulozi
int nacitaj_gps(GPS *gps) {

	printf("Zadaj zemepisnu sirku: ");
	scanf("%lf", &gps->lat);
	//pozn.: operator -> ma vyssiu prioritu
	// najprv sa spristupni gps->lat
	// a potom pomocou & sa adresa tohto double posle do scanf

	printf("Zadaj zemepisnu dlzku: ");
	scanf("%lf", &gps->lon);
	
	//vratime nejaky ciselny kod,
     // vo funkcii by sme mohli napr. osetrit, ci scanf boli ok
	return 1;
}

//Funkcia na vypis lokality
//vstupom je lokalita, formatovane ju vypise
void vypis_lokalitu(const Lokalita *lokalita) {
	printf("%s ma suradnice %.5lf %.5lf\n",
		lokalita->nazov,
		lokalita->gps.lat,
		lokalita->gps.lon);
}

int main() {
	Lokalita vlastna = {"test", {0.0,0.0}};  
	//do funkcie posielame adresu nejakej GPS struktury
	// . ma prednost, najprv sa spristupni lokalita.gps
	// a cez & zisti jej adresa, ktora sa posle do funkcie                   
	if (nacitaj_gps(&vlastna.gps));
		vypis_lokalitu(&vlastna);
}

#include

/// Definicie typov

/// Zlozky GPS suradnic

typedef double gps_ns;

typedef double gps_ew;

/// GPS suradnice

typedef struct _gps { gps_ns lat; gps_ew lon; } GPS;

/// Lokalita, spaja nazov so suradnicami

typedef struct _lokalita {

char nazov[31];

GPS gps;

} Lokalita;

//chceme nacitat gps suradnicu z klavesnice cez scanf

// vstupom je adresa struktury, kam sa suradnica ulozi

int nacitaj_gps(GPS *gps) {

printf("Zadaj zemepisnu sirku: ");

scanf("%lf", &gps->lat);

//pozn.: operator -> ma vyssiu prioritu

// najprv sa spristupni gps->lat

// a potom pomocou & sa adresa tohto double posle do scanf

printf("Zadaj zemepisnu dlzku: ");

scanf("%lf", &gps->lon);

//vratime nejaky ciselny kod,

// vo funkcii by sme mohli napr. osetrit, ci scanf boli ok

return 1;

}

//Funkcia na vypis lokality

//vstupom je lokalita, formatovane ju vypise

void vypis_lokalitu(const Lokalita *lokalita) {

printf("%s ma suradnice %.5lf %.5lf\n",

lokalita->nazov,

lokalita->gps.lat,

lokalita->gps.lon);

}

int main() {

Lokalita vlastna = {"test", {0.0,0.0}};

//do funkcie posielame adresu nejakej GPS struktury

// . ma prednost, najprv sa spristupni lokalita.gps

// a cez & zisti jej adresa, ktora sa posle do funkcie

if (nacitaj_gps(&vlastna.gps));

vypis_lokalitu(&vlastna);

}

Prednáška 9 [PDF]

/***
 * Demo 01: nacitanie celeho textoveho suboru do retazca
            a zapisanie do druheho suboru
            
   Vyuziva fseek na zistenie velkosti suboru a dynamicku alokaciu.
   Vhodne iba pre kratke textove subory, kedze cely subor sa presunie 
   do pamate ako jeden velky string.
 *
 ***/
  
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

//  POPIS read_file():
//      Funkcia, ktora precita obsah suboru (fname) do C retazca
//      a vrati pointer na jeho zaciatok.
//  IN:
//      fname   - retazec obsahujuci nazov suboru
//  OUT:
//      char*   - pointer na retazec, ktory obsahuje
//              precitany text zo suboru
//
//    Equivalent v Pythone: file.read()
char* read_file(const char* fname)
{
	FILE * f;
	size_t len,pos;
	char c;
	char* out;
	
	f = fopen(fname, "rt"); // otvarame subor v textovom rezime
	if (f == NULL) // kontrolujeme, ci otvaranie prebehlo OK
		return NULL;

	pos = ftell(f);    // aktualna pozicia
    fseek(f, 0, SEEK_END);    // presunieme sa na koniec suboru
    len = ftell(f); // zistenie aktualnej pozicie v subore
    fseek(f, pos, SEEK_SET);  // vratenie sa na zaciatok suboru

	out = (char*)malloc(len+1); // alokujeme pamat pre retazec + 1 ukoncovaci znak
	if(out == NULL){
        fprintf(stderr, "Alokacia pamate zlyhala.\n");
		exit(-1);        
	}

	// nacitanie suboru do retazca
	len=0;
	
	// Nacitavame znak, pokym nenacitame EOF (end of file)
    // c=fgetc(f) je potrebne ozatvorkovat, 
    //  inak by sa do c ulozil vysledok porovnania
	while((c=fgetc(f)) != EOF){
        out[len++] = c;
	}
	out[len] = '\0'; // vlozime ukoncovaci znak a tak vytvorime platny C retazec
	fclose(f); // zavrieme subor
	return out;
}

//  POPIS write_file():
//      Funkcia, ktora zapise obsah C retazca (text) do suboru (fname)
//      a vrati 0/1 ak sa nepodarilo/podarilo operaciu zrealizovat.
//  IN:
//      fname   - retazec obsahujuci nazov suboru
//      text    - retazec, ktory sa chystame zapisat do suboru
//  OUT:
//      int     - ciselna hodnota signalizujuca uspesne/neuspesne
//              dokoncenie funkcie
//
//    Equivalent v Pythone: file.write()

int write_file(const char* fname, const char* text)
{
	FILE * f;
	int numbytes = 0;
	
	f = fopen(fname, "wt"); // otvarame subor
	if (f == NULL) // kontrolujeme uspesnost otvorenia
		return 0;

	numbytes = fprintf(f, "%s", text); // zapiseme retazec do suboru
	//mohli by sme aj pouzit cyklus s fputc...
	
	fclose(f); // zavrieme subor

	return numbytes;
}

int main(int argc, char*argv[])
{
    char *data;
    
    //skontrolujeme, ci mame parametre
    if (argc < 3)
    {
        fprintf(stderr, "Pouzitie: %s input output\n", argv[0]);
        return -1;
    }
    
    //nacitame subor
    data = read_file(argv[1]);
    
    //TODO: spracujeme udaje v data...
    
    write_file(argv[2], data);
    
    return 0;
}

100

101

102

103

104

105

106

107

108

109

/***

* Demo 01: nacitanie celeho textoveho suboru do retazca

a zapisanie do druheho suboru

Vyuziva fseek na zistenie velkosti suboru a dynamicku alokaciu.

Vhodne iba pre kratke textove subory, kedze cely subor sa presunie

do pamate ako jeden velky string.

***/

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

// POPIS read_file():

// Funkcia, ktora precita obsah suboru (fname) do C retazca

// a vrati pointer na jeho zaciatok.

// IN:

// fname - retazec obsahujuci nazov suboru

// OUT:

// char* - pointer na retazec, ktory obsahuje

// precitany text zo suboru

// Equivalent v Pythone: file.read()

char* read_file(const char* fname)

{

FILE * f;

size_t len,pos;

char c;

char* out;

f = fopen(fname, "rt"); // otvarame subor v textovom rezime

if (f == NULL) // kontrolujeme, ci otvaranie prebehlo OK

return NULL;

pos = ftell(f); // aktualna pozicia

fseek(f, 0, SEEK_END); // presunieme sa na koniec suboru

len = ftell(f); // zistenie aktualnej pozicie v subore

fseek(f, pos, SEEK_SET); // vratenie sa na zaciatok suboru

out = (char*)malloc(len+1); // alokujeme pamat pre retazec + 1 ukoncovaci znak

if(out == NULL){

fprintf(stderr, "Alokacia pamate zlyhala.\n");

exit(-1);

}

// nacitanie suboru do retazca

len=0;

// Nacitavame znak, pokym nenacitame EOF (end of file)

// c=fgetc(f) je potrebne ozatvorkovat,

// inak by sa do c ulozil vysledok porovnania

while((c=fgetc(f)) != EOF){

out[len++] = c;

}

out[len] = '\0'; // vlozime ukoncovaci znak a tak vytvorime platny C retazec

fclose(f); // zavrieme subor

return out;

}

// POPIS write_file():

// Funkcia, ktora zapise obsah C retazca (text) do suboru (fname)

// a vrati 0/1 ak sa nepodarilo/podarilo operaciu zrealizovat.

// IN:

// fname - retazec obsahujuci nazov suboru

// text - retazec, ktory sa chystame zapisat do suboru

// OUT:

// int - ciselna hodnota signalizujuca uspesne/neuspesne

// dokoncenie funkcie

// Equivalent v Pythone: file.write()

int write_file(const char* fname, const char* text)

{

FILE * f;

int numbytes = 0;

f = fopen(fname, "wt"); // otvarame subor

if (f == NULL) // kontrolujeme uspesnost otvorenia

return 0;

numbytes = fprintf(f, "%s", text); // zapiseme retazec do suboru

//mohli by sme aj pouzit cyklus s fputc...

fclose(f); // zavrieme subor

return numbytes;

}

int main(int argc, char*argv[])

{

char *data;

//skontrolujeme, ci mame parametre

if (argc < 3)

{

fprintf(stderr, "Pouzitie: %s input output\n", argv[0]);

return -1;

}

//nacitame subor

data = read_file(argv[1]);

//TODO: spracujeme udaje v data...

write_file(argv[2], data);

return 0;

}

/***
 * Demo 02: podobne ako demo01, ale kopirujeme lubovolne binarne subory
      (aj velmi velke)
    
    Funkcie dostavaju na vstup otvorene subory. Subory otvorime v main.
 *
 ***/

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

//funkcia kopiruje data z jedneho otvoreneho suboru do druheho
int copy(FILE* fin, FILE* fout);
int copy_char(FILE* fin, FILE* fout);


//copy file1 to file2 -> z command line
// ak nema parameter vystupny, kopiruje sa na standardny vystup
int main(int argc, char* argv[])
{
    FILE *in, *out;  //chceme pracovat s 2 subormi
    
    //vyuzijeme parametre z prikazoveho riadku
	if (argc < 2)
	{
		fprintf(stderr, "files MENO1 [MENO2]\n");
		return -1;
	}
	
	//najprv otvorime vstupny subor (a overime, ci existuje)
	in = fopen(argv[1], "rb");  //"rb" - read binary
	if (in == NULL)
	{
		fprintf(stderr, "%s sa neda otvorit na citanie\n", argv[1]);
		return -1;
	}
	
	//POST: tu mame otvoreny in subor
	
    if (argc < 3)
    {
        //vystupny subor nie je zadany, pouzijeme standardny vystup	
        out = stdout;
    }
    else
    {
        //pokusime sa otvorit vystupny subor
        out = fopen(argv[2], "wb");  //"wb" - write binary
        
        if (out == NULL)
        {
		    fprintf(stderr, "%s sa neda otvorit na zapis\n", argv[2]);
		    fclose(in);  //otvorili sme ho, treba ho zavriet...
		    return -1;   
        }
    }
	//POST: tu mame otvoreny in subor aj out subor
	
	//TODO: porovnajte si, kolko trva kopirovanie ktorou funkciou 
	//      napr. na nejakom video subore (cez 1GB)
	//copy_char(in, out);
	copy(in, out);
	
    //skoncili sme pracu so subormi, zavrieme ich
    fclose(in);
    if (out != stdout) 
    {
        fclose(out);
    }
    	
	return 0;
}


//funkcia kopiruje binarne subory znak po znaky,
int copy_char(FILE* fin, FILE* fout)
{
	int i;
		
	while ( (i = getc(fin)) != EOF )
		putc(i, fout);
	
	return 0;
}

#define SIZE (1024*1024) 

//funkcia skopiruje obsah suboru s pomocou vyrovnavacej pamate (fread/fwrite)
// rychlejsie ako znak po znaku
int copy(FILE* fin, FILE* fout)
{
	static char buffer[SIZE];
	size_t pocet;
	
	// fread nacita kolko sa da, vrati nacitany pocet znakov
	while ( (pocet = fread(buffer, sizeof(char), SIZE, fin) ) > 0 )
	{
		//fwrite potom nacitane znaky zapise do druheho suboru
		fwrite(buffer, sizeof(char), pocet, fout);
	}
	
	return 0;
}

100

101

102

103

104

/***

* Demo 02: podobne ako demo01, ale kopirujeme lubovolne binarne subory

(aj velmi velke)

Funkcie dostavaju na vstup otvorene subory. Subory otvorime v main.

***/

#include <stdio.h>

#include <stdlib.h>

#include <memory.h>

//funkcia kopiruje data z jedneho otvoreneho suboru do druheho

int copy(FILE* fin, FILE* fout);

int copy_char(FILE* fin, FILE* fout);

//copy file1 to file2 -> z command line

// ak nema parameter vystupny, kopiruje sa na standardny vystup

int main(int argc, char* argv[])

{

FILE *in, *out; //chceme pracovat s 2 subormi

//vyuzijeme parametre z prikazoveho riadku

if (argc < 2)

{

fprintf(stderr, "files MENO1 [MENO2]\n");

return -1;

}

//najprv otvorime vstupny subor (a overime, ci existuje)

in = fopen(argv[1], "rb"); //"rb" - read binary

if (in == NULL)

{

fprintf(stderr, "%s sa neda otvorit na citanie\n", argv[1]);

return -1;

}

//POST: tu mame otvoreny in subor

if (argc < 3)

{

//vystupny subor nie je zadany, pouzijeme standardny vystup

out = stdout;

}

else

{

//pokusime sa otvorit vystupny subor

out = fopen(argv[2], "wb"); //"wb" - write binary

if (out == NULL)

{

fprintf(stderr, "%s sa neda otvorit na zapis\n", argv[2]);

fclose(in); //otvorili sme ho, treba ho zavriet...

return -1;

}

//POST: tu mame otvoreny in subor aj out subor

//TODO: porovnajte si, kolko trva kopirovanie ktorou funkciou

// napr. na nejakom video subore (cez 1GB)

//copy_char(in, out);

copy(in, out);

//skoncili sme pracu so subormi, zavrieme ich

fclose(in);

if (out != stdout)

{

fclose(out);

}

return 0;

}

//funkcia kopiruje binarne subory znak po znaky,

int copy_char(FILE* fin, FILE* fout)

{

int i;

while ( (i = getc(fin)) != EOF )

putc(i, fout);

return 0;

}

#define SIZE (1024*1024)

//funkcia skopiruje obsah suboru s pomocou vyrovnavacej pamate (fread/fwrite)

// rychlejsie ako znak po znaku

int copy(FILE* fin, FILE* fout)

{

static char buffer[SIZE];

size_t pocet;

// fread nacita kolko sa da, vrati nacitany pocet znakov

while ( (pocet = fread(buffer, sizeof(char), SIZE, fin) ) > 0 )

{

//fwrite potom nacitane znaky zapise do druheho suboru

fwrite(buffer, sizeof(char), pocet, fout);

}

return 0;

}

#include <stdio.h>
#include <ctype.h>
/***
 * Demo 03: zo vstupneho suboru vyberieme vsetky (kladne) cisla 
            v desiatkovej sustave 
        a vypiseme ich do vystupneho suboru (na konzolu v priklade)
 *
 ***/

//funkcia kopiruje textove subory obsahujuce cisla v desiatkovej sustave
// TODO (tazsia uloha): funkcia nefunguje so zapornymi cislami, 
//                      vedeli by ste ju opravit?
int copy_ints(FILE* fin, FILE* fout)
{
	int i, c, count = 0;
	
	//vyuzivame kontrolu, ci sme vycerpali cely subor, funkciou feof
	while (!feof(fin))
	{
	    //preskakujeme znaky, ktore nie su cislice
	    c = fgetc(fin);
	    if (!isdigit(c))
	       continue;
	    
	    //c je cislica, vratime ju do vstupneho suboru
	    // aby sme ju mohli nacitat v ramci cisla
	    ungetc(c, fin);
	    
	    fscanf(fin, "%d", &i);
	    //vypiseme kazde nacitane cislo na vystup
        fprintf(fout, "%d\n", i);
        count++;
    }
	return count;
}

int main(int argc, char* argv[])
{
    //otvorime subor, ak mame zadany parameter
    FILE *f = argc > 1 ? fopen(argv[1],"r") : NULL;
    int count;
    
    if (f != NULL)
    {
        //vykopirujeme cisla na standardny vystup 
        // (vyskusajte napr. s tymto zdrojakom)
        count = copy_ints(f, stdout); 
        fclose(f);
        
        //na standardny chybovy vystup zapiseme, kolko ich bolo
        // stdout sa da presmerovat do suboru, a toto nechat na konzole
        fprintf(stderr, "Vstupny subor obsahoval %i cisel\n", count);
    }
    return 0;
}

#include <stdio.h>

#include <ctype.h>

/***

* Demo 03: zo vstupneho suboru vyberieme vsetky (kladne) cisla

v desiatkovej sustave

a vypiseme ich do vystupneho suboru (na konzolu v priklade)

***/

//funkcia kopiruje textove subory obsahujuce cisla v desiatkovej sustave

// TODO (tazsia uloha): funkcia nefunguje so zapornymi cislami,

// vedeli by ste ju opravit?

int copy_ints(FILE* fin, FILE* fout)

{

int i, c, count = 0;

//vyuzivame kontrolu, ci sme vycerpali cely subor, funkciou feof

while (!feof(fin))

{

//preskakujeme znaky, ktore nie su cislice

c = fgetc(fin);

if (!isdigit(c))

continue;

//c je cislica, vratime ju do vstupneho suboru

// aby sme ju mohli nacitat v ramci cisla

ungetc(c, fin);

fscanf(fin, "%d", &i);

//vypiseme kazde nacitane cislo na vystup

fprintf(fout, "%d\n", i);

count++;

}

return count;

}

int main(int argc, char* argv[])

{

//otvorime subor, ak mame zadany parameter

FILE *f = argc > 1 ? fopen(argv[1],"r") : NULL;

int count;

if (f != NULL)

{

//vykopirujeme cisla na standardny vystup

// (vyskusajte napr. s tymto zdrojakom)

count = copy_ints(f, stdout);

fclose(f);

//na standardny chybovy vystup zapiseme, kolko ich bolo

// stdout sa da presmerovat do suboru, a toto nechat na konzole

fprintf(stderr, "Vstupny subor obsahoval %i cisel\n", count);

}

return 0;

}

Prednáška 10 [PDF]

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

//priklad pouzitia dvojrozmerneho statickeho pola
int main()
{
	double sustava[3][4] = { 
       {-1, 1, 0,0.5}, 
       { 0, 1, 1,2.5}, 
       { 2, 1,-1, -1} 
    };

    //vypis ako sustava:
	for (int i = 0; i < 3; i++)
    {
      for (int j = 0; j < 3; j++)
      {
        printf("%4.1lf ", sustava[i][j]);
      }
      printf("| %4.1lf\n", sustava[i][3]);
    }
    
    //vypis transponovane (zamenene stlpce/riadky)
    for (int i = 0; i < 4; i++)
    {
      for (int j = 0; j < 3; j++)
      {
        printf("%4.1lf ", sustava[j][i]);
      }
      printf("\n");
    }
	
	return 0;
}

#include <stdio.h>

#include <stdlib.h>

//priklad pouzitia dvojrozmerneho statickeho pola

int main()

{

double sustava[3][4] = {

{-1, 1, 0,0.5},

{ 0, 1, 1,2.5},

{ 2, 1,-1, -1}

};

//vypis ako sustava:

for (int i = 0; i < 3; i++)

{

for (int j = 0; j < 3; j++)

{

printf("%4.1lf ", sustava[i][j]);

}

printf("| %4.1lf\n", sustava[i][3]);

}

//vypis transponovane (zamenene stlpce/riadky)

for (int i = 0; i < 4; i++)

{

for (int j = 0; j < 3; j++)

{

printf("%4.1lf ", sustava[j][i]);

}

printf("\n");

}

return 0;

}

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

#define MAX_RIADKY 100
#define MAX_STLPCE 100

//prvy rozmer matice mozeme vynechat, ostatne nie
void vypis(double matica[][MAX_STLPCE], int riadky, int stlpce) {
	for (int r = 0; r < riadky; r++) {
         printf( "[%lf", matica[r][0] ); 
         for (int s = 1; s < stlpce; s++) {
            printf( ", %lf", matica[r][s] ); 
         }
         printf( "]\n" );
     }
}

//priklad pouzitia dvojrozmerneho statickeho pola
int main()
{
	static double sustava[MAX_RIADKY][MAX_STLPCE] = { 
       {-1, 1, 0,0.5}, 
       { 0, 1, 1,2.5}, 
       { 2, 1,-1, -1} 
    };

    //vypis celu sustava:
    vypis(sustava, 3, 4);
    
    //vypis bez pravych stran
    vypis(sustava, 3, 3);

    //vypis posledneho riadku
    // sustava + 2 je to iste ako &sustava[2], 
    // zaciatok druheho riadku, typu double(*)[MAX_STLPCE]
    vypis(sustava+2, 1, 3);

	
	return 0;
}

#include <stdio.h>

#include <stdlib.h>

#define MAX_RIADKY 100

#define MAX_STLPCE 100

//prvy rozmer matice mozeme vynechat, ostatne nie

void vypis(double matica[][MAX_STLPCE], int riadky, int stlpce) {

for (int r = 0; r < riadky; r++) {

printf( "[%lf", matica[r][0] );

for (int s = 1; s < stlpce; s++) {

printf( ", %lf", matica[r][s] );

}

printf( "]\n" );

}

//priklad pouzitia dvojrozmerneho statickeho pola

int main()

{

static double sustava[MAX_RIADKY][MAX_STLPCE] = {

{-1, 1, 0,0.5},

{ 0, 1, 1,2.5},

{ 2, 1,-1, -1}

};

//vypis celu sustava:

vypis(sustava, 3, 4);

//vypis bez pravych stran

vypis(sustava, 3, 3);

//vypis posledneho riadku

// sustava + 2 je to iste ako &sustava[2],

// zaciatok druheho riadku, typu double(*)[MAX_STLPCE]

vypis(sustava+2, 1, 3);

return 0;

}

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

#define MAX_WORDS 100
#define MAX_LEN 30
#define MAX_LEN_S "30"

//nacita slova do zadaneho pola slov, kazde je dlzky MAX_LEN
int read_words(char words[][MAX_LEN+1], int max_words) {
	int nwords = 0;
     while (nwords < max_words) {
         
          //tu words[nwords] je adresa typu char*
          //ukazuje na miesto, kde sa da ulozit MAX_LEN dlhy retazec

		if (scanf("%" MAX_LEN_S "s", words[nwords]) < 1)
			break;
          //pozn.: ked sa napisu v C vedla seba retazce, prekladac ich spoji
          //       preto funguje "%" MAX_LEN_S "s", po preklade: "%30s"

		nwords++;	
     }
     return nwords;
}

//vypise slova, kazde na novy riadok
void print_words(char words[][MAX_LEN+1], int nwords) {
	for (int i = 0; i < nwords; i++)
		printf("%s\n", words[i]);
}

int main()
{
    char words[MAX_WORDS][MAX_LEN+1];
    int nwords;
    
    nwords = read_words(words, MAX_WORDS);
    print_words(words, nwords);
    
    return 0;
}

#include <stdio.h>

#include <stdlib.h>

#define MAX_WORDS 100

#define MAX_LEN 30

#define MAX_LEN_S "30"

//nacita slova do zadaneho pola slov, kazde je dlzky MAX_LEN

int read_words(char words[][MAX_LEN+1], int max_words) {

int nwords = 0;

while (nwords < max_words) {

//tu words[nwords] je adresa typu char*

//ukazuje na miesto, kde sa da ulozit MAX_LEN dlhy retazec

if (scanf("%" MAX_LEN_S "s", words[nwords]) < 1)

break;

//pozn.: ked sa napisu v C vedla seba retazce, prekladac ich spoji

// preto funguje "%" MAX_LEN_S "s", po preklade: "%30s"

nwords++;

}

return nwords;

}

//vypise slova, kazde na novy riadok

void print_words(char words[][MAX_LEN+1], int nwords) {

for (int i = 0; i < nwords; i++)

printf("%s\n", words[i]);

}

int main()

{

char words[MAX_WORDS][MAX_LEN+1];

int nwords;

nwords = read_words(words, MAX_WORDS);

print_words(words, nwords);

return 0;

}

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

//klasicky vypis matice
void vypis(FILE * out, int** matica, int nr, int ns)
{
	int r, s;
	
	for (r = 0; r < nr; r++)
	{
		for (s = 0; s < ns; s++)
		{
			fprintf(out, "%3d ", matica[r][s]);
		}
		fprintf(out, "\n");
	}
}

int**  vytvor1(int nr, int ns)
{
	int** ptr;
	int r;
	//zakladna alokacia, vytvorime zvlast pole smernikov
	ptr = (int**) calloc(nr, sizeof(int*));
	
	//a potom ku kazdemu alokujeme pamat potrebnej velkosti
	for (r = 0; r < nr; r++)
	{
		ptr[r] = (int*) calloc(ns, sizeof(int));
	}
	
	return ptr;
}

void uvolni1(int** ptr, int nr)
{
    int r;
    //najprv musime uvolnit obsah riadkov, potom pointery
    for (r = 0; r < nr; r++)
        free(ptr[r]);
    free(ptr);
}

int**  vytvor2(int nr, int ns)
{
	int** ptr;
	int r;
	
	//alokujeme za sebou pamat pre nr smernikov
	// a potom nr*ns celych cisel
	ptr = (int**) malloc(nr*sizeof(int*)+nr*ns*sizeof(int));
	
	//nastavime ptr[0] aby ukazoval za pole smernikov
    // pretypujeme na spravny typ 
	ptr[0] = (int*)(ptr+nr);
	for (r = 1; r < nr; r++)
	{
	    //nasledujuci smernik je posunuty o ns pozicii od predosleho
		ptr[r]= ptr[r-1] + ns;
	}
	return ptr;
}

int main(int argc, char* argv[])
{
	//dynamicka alokacia:
	int nr = 10, ns = 5;
	int** matica;
	
	matica = vytvor1(nr, ns);
	//pouzitie dynamickej matice je jednoduche,
	// kedze sa pouzil calloc, mala by obsahovat same 0
	vypis(stdout, matica, nr, ns);
	//uvolnenie pamate je v pripade 1 komplikovane, nestaci free
	uvolni1(matica, nr);
	
	//efektivnejsia matica:
	matica = vytvor2(ns, nr);
	//pozor, obsah matice je teraz nedefinovany, kedze sa pouzil malloc
	vypis(stdout, matica, ns, nr);
    //vytvor2 volala len 1 malloc, staci free
	free(matica);
	
	
	return 0;
}

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

//klasicky vypis matice

void vypis(FILE * out, int** matica, int nr, int ns)

{

int r, s;

for (r = 0; r < nr; r++)

{

for (s = 0; s < ns; s++)

{

fprintf(out, "%3d ", matica[r][s]);

}

fprintf(out, "\n");

}

int** vytvor1(int nr, int ns)

{

int** ptr;

int r;

//zakladna alokacia, vytvorime zvlast pole smernikov

ptr = (int**) calloc(nr, sizeof(int*));

//a potom ku kazdemu alokujeme pamat potrebnej velkosti

for (r = 0; r < nr; r++)

{

ptr[r] = (int*) calloc(ns, sizeof(int));

}

return ptr;

}

void uvolni1(int** ptr, int nr)

{

int r;

//najprv musime uvolnit obsah riadkov, potom pointery

for (r = 0; r < nr; r++)

free(ptr[r]);

free(ptr);

}

int** vytvor2(int nr, int ns)

{

int** ptr;

int r;

//alokujeme za sebou pamat pre nr smernikov

// a potom nr*ns celych cisel

ptr = (int**) malloc(nr*sizeof(int*)+nr*ns*sizeof(int));

//nastavime ptr[0] aby ukazoval za pole smernikov

// pretypujeme na spravny typ

ptr[0] = (int*)(ptr+nr);

for (r = 1; r < nr; r++)

{

//nasledujuci smernik je posunuty o ns pozicii od predosleho

ptr[r]= ptr[r-1] + ns;

}

return ptr;

}

int main(int argc, char* argv[])

{

//dynamicka alokacia:

int nr = 10, ns = 5;

int** matica;

matica = vytvor1(nr, ns);

//pouzitie dynamickej matice je jednoduche,

// kedze sa pouzil calloc, mala by obsahovat same 0

vypis(stdout, matica, nr, ns);

//uvolnenie pamate je v pripade 1 komplikovane, nestaci free

uvolni1(matica, nr);

//efektivnejsia matica:

matica = vytvor2(ns, nr);

//pozor, obsah matice je teraz nedefinovany, kedze sa pouzil malloc

vypis(stdout, matica, ns, nr);

//vytvor2 volala len 1 malloc, staci free

free(matica);

return 0;

}

Prednáška 11 [PDF]

#include <stdio.h>

//vypise v binarnom tvare cislo, ako unsigned int
void binary(unsigned int number) {
   
   for (int k = 31; k >= 0; k--)
   {
       printf("%i", (number >> k) & 1);
       if ((k&0x7) == 0)         //to iste co k % 8, ale pozor na zatvorkovanie!
          printf(" ");
   }
   // number sa posunie o k bitov, k-ty bit bude LSB,
   // operacia x&1 vyberie len LSB z x
}

//vypise v binarnom tvare obsah pamate od nejakej adresy
void binary_mem(unsigned char *mem, int len) {
    static char out[9] = "";
    unsigned char c;
    for (int i = 0; i < len; i++)
    {
        c = *mem++;  //vyberie nasledovny znak a posunie sa v pamati
       //je rychlejsie robit jednu printf operaciu a bez cyklov...
       // MSB ide do out[0], LSB do out[1]
       out[7] = '0' + ((c>>0) & 1);   //pozor na zatvorkovanie!, & ma nizsiu prioritu ako +
       out[6] = '0' + ((c>>1) & 1);
       out[5] = '0' + ((c>>2) & 1);
       out[4] = '0' + ((c>>3) & 1);
       out[3] = '0' + ((c>>4) & 1);
       out[2] = '0' + ((c>>5) & 1);
       out[1] = '0' + ((c>>6) & 1);
       out[0] = '0' + ((c>>7) & 1);
       printf("%s ", out);
    }
 }


int main()
{
    unsigned int a = 0xdeadbeef;
    unsigned int b = 0x0f3c5a;
    
    printf("\nBinarny vypis a   : ");
    binary(a);
    printf("\nBinarne od &a     : ");
    binary_mem((unsigned char*)&a, sizeof(a));

    printf("\nBinarny vypis b   : ");
    binary(b);
    
    printf("\nBinarny vypis ~b  : ");
    binary(~b);
    printf("\nBinarny vypis a|b : ");
    binary(a|b);
    printf("\nBinarny vypis a&b : ");
    binary(a&b);
    printf("\nBinarny vypis a^b : ");
    binary(a^b);
    printf("\nBinarny vypis b>>4: ");
    binary(b>>4);
    printf("\nBinarny vypis b<<4: ");
    binary(b<<4);
    return 0;
}

#include <stdio.h>

//vypise v binarnom tvare cislo, ako unsigned int

void binary(unsigned int number) {

for (int k = 31; k >= 0; k--)

{

printf("%i", (number >> k) & 1);

if ((k&0x7) == 0) //to iste co k % 8, ale pozor na zatvorkovanie!

printf(" ");

}

// number sa posunie o k bitov, k-ty bit bude LSB,

// operacia x&1 vyberie len LSB z x

}

//vypise v binarnom tvare obsah pamate od nejakej adresy

void binary_mem(unsigned char *mem, int len) {

static char out[9] = "";

unsigned char c;

for (int i = 0; i < len; i++)

{

c = *mem++; //vyberie nasledovny znak a posunie sa v pamati

//je rychlejsie robit jednu printf operaciu a bez cyklov...

// MSB ide do out[0], LSB do out[1]

out[7] = '0' + ((c>>0) & 1); //pozor na zatvorkovanie!, & ma nizsiu prioritu ako +

out[6] = '0' + ((c>>1) & 1);

out[5] = '0' + ((c>>2) & 1);

out[4] = '0' + ((c>>3) & 1);

out[3] = '0' + ((c>>4) & 1);

out[2] = '0' + ((c>>5) & 1);

out[1] = '0' + ((c>>6) & 1);

out[0] = '0' + ((c>>7) & 1);

printf("%s ", out);

}

int main()

{

unsigned int a = 0xdeadbeef;

unsigned int b = 0x0f3c5a;

printf("\nBinarny vypis a : ");

binary(a);

printf("\nBinarne od &a : ");

binary_mem((unsigned char*)&a, sizeof(a));

printf("\nBinarny vypis b : ");

binary(b);

printf("\nBinarny vypis ~b : ");

binary(~b);

printf("\nBinarny vypis a|b : ");

binary(a|b);

printf("\nBinarny vypis a&b : ");

binary(a&b);

printf("\nBinarny vypis a^b : ");

binary(a^b);

printf("\nBinarny vypis b>>4: ");

binary(b>>4);

printf("\nBinarny vypis b<<4: ");

binary(b<<4);

return 0;

}