Kody programów [PO]

Informacje praktyczne oraz kody programów demonstrowanych na wykładzie:

VC++2019: Błąd kompilacji C4996

Aby uniknąć błędu kompilacji C4996 występującym, kiedy używamy starszych wersji niektórych funkcji bibliotecznych (np. strcpy, fopen, etc.) uznanych przez kompilator za deprecated (przestarzałe) względem wersji określonej w aktualnych ustawieniach kompilatora, należy w pierwszej linii pliku cpp (albo c) napisać dyrektywę preprocesora:
#define _CRT_SECURE_NO_WARNINGS
albo
#pragma warning( disable : 4996 )

VC++2019: Ostrzeżenie kompilacji C6031 (ignorowana wartość zwrotna)

Aby nie pojawiało się ostrzeżenie o ignorowaniu wartości zwrotnej np. w przypadku wywołania scanf czy fscanf, należy na początku pliku napisać dyrektywę preprocesora:
#pragma warning( disable : 6031 )

Automatyczne zamykanie okna konsoli

Aby wyłączyć automatyczne zamykanie okna konsoli po zatrzymaniu debugowania należy w menu wybrać “Narzędzia -> Opcje” i w otwartym oknie zgasić znacznik przy pozycji “automatycznie zamknij konsolę zatrzymaniu debugowania”:
VS2019: zamykanie okna konsoli

Program #1


#include <stdio.h>

struct para {
	int l;
	char n[20];
};

int silnia(int x)
{
    int i, wynik = 1;
    for(i = 2; i < = x; i++)
        wynik *= i;
    return wynik;
}

int main() {
	struct para t[5];
	int wynik,a=4;
	wynik = silnia(a);
	printf("silnia z %i = %i\n", a,wynik);
	a++;
	wynik = silnia(a);
	printf("silnia z %i = %i\n", a,wynik);
	return 0;
}

Program #2


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

int main(int argc, char *argv[]) {
	size_t rozmiar;
	FILE   *stream, *stream2;
	fpos_t pos;
	unsigned char buffer[100000] = {0};

	if( (stream = fopen( argv[1], "rb" )) == NULL ) {
		printf( "Nie mogę otworzyć pliku do odczytu.\n" );
		return 0;
	}
	else {
		fseek( stream, 0L, SEEK_END);
		if( fgetpos( stream, &pos ) != 0 ) {
			perror( "fgetpos error" );
			return -1;
		}
		rozmiar = (int)pos;
		fseek( stream, 0L, SEEK_SET);
		if( (stream2 = fopen( argv[2], "wb" )) == NULL ) {
			printf( "Nie mogę otworzyć pliku do zapisu.\n" );
			fclose(stream);
			return 0;
		}
		fread(buffer, sizeof( unsigned char ), rozmiar, stream);
		fwrite(buffer, sizeof( unsigned char ), rozmiar, stream2);
		fclose(stream2);
		fclose(stream);
	}
	return 0;
}

Program #3


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

struct paczka {
	int x;
	char s[10];
	struct paczka* p;
};

int main() {
	struct paczka pa;
	struct paczka *ptr;
	pa.x = 5;
	strcpy(pa.s,"kopytko",8);
	pa.p = NULL;

	ptr = malloc(sizeof(struct paczka));
	memcpy(ptr, &pa, sizeof(struct paczka));

	ptr->p = malloc(sizeof(struct paczka));
	memcpy(ptr->p, &pa, sizeof(struct paczka));

	free(ptr->p); 
	free(ptr);
	return 0;
}

Program #4

main.c


#include <stdlib.h>
#include <stdio.h>
#include "libA.h"
#include "libB.h"

int main() {
	char s[] = "AmBi_WaLeN_tNy";
	struct klucz k = {"AaBbCcDdEe",3};

	szyfratorA(s,k);
	printf("%s\n", s);
	szyfratorB(s,k);
	printf("%s\n", s);
	
	system("PAUSE");
	return 0;
}

libA.h


#ifndef libA_h
#define libA_h

#include "libC.h"

void szyfratorA(char *s, struct klucz k);

#endif

libA.c


#include <ctype.h>
#include "libA.h"

// szyfrator małych liter
void szyfratorA(char *s, struct klucz k) {
	int i;
	for(i=0;s[i]!=0;i++)
	if (isalpha(s[i]))
		if (islower(s[i])) s[i] = flip(s[i],k);
}

libB.h


#ifndef libB_h
#define libB_h

#include "libC.h"

void szyfratorB(char *s, struct klucz k);

#endif

libB.c


#include <ctype.h>
#include "libB.h"

// szyfrator dużych liter
void szyfratorB(char *s, struct klucz k) {
	int i;
	for(i=0;s[i]!=0;i++)
	if (isalpha(s[i]))
		if (isupper(s[i])) s[i] = flip(s[i],k);
}

libC.h


#ifndef libC_h
#define libC_h

char flip(char c, struct klucz k);

struct klucz {
	char mapa[10];
	int skok;
};

#endif

libC.c


#include "libC.h"

char flip(char c, struct klucz k) {
	int i;
	for(i=0;i<24; i++)
		if (c==k.mapa[i]) return k.mapa[(i+k.skok)%10];
	return c;
}

Program #5


#include <cstdio>
using namespace std;

class gabka {
	float woda;
public:
	void nasacz(float ml) {
		woda = ml;
	}
	float wycisnij(void) {
		return woda/=2;
	}
};
int main() {
	float szklanka = 0; // pusta szklanka
	gabka g;            // nowa sucha gąbka
	g.nasacz(100);      // nasączam gąbkę wodą
	for (int i=0; i < 3; i++)
		szklanka += g.wycisnij();

	printf("%f\n", szklanka);
	// printf("%f\n", g.woda); czy wolno mi tak napisać?
	return 0;
}

Program #6


#include <cstdio>
#include <cstring>
using namespace std;

class MojaKlasa {
	char **email; 
	int ile;
	public:
	MojaKlasa(int x);
	MojaKlasa(MojaKlasa& mk);	// konstruktor kopiujący
	void setemail(char* adres, int idx) { strcpy(email[idx],adres); }
	char* getemail(int idx) { return email[idx]; }
};
MojaKlasa:: MojaKlasa(int x) {
	email = new char*[ile = x];
	for (int i=0;i<ile;i++) email[i] = new char[100];
}

MojaKlasa::MojaKlasa(MojaKlasa& mk) {
	email = mk.email;			// czy to jest OK?
}
/*
MojaKlasa::MojaKlasa(MojaKlasa& mk) {
	email = new char*[mk.ile];
	ile = mk.ile;
	for (int i=0;i<ile;i++) {
		email[i] = new char[100];
		strcpy(email[i],mk.email[i]);
	}
}
*/
int main() {
	MojaKlasa MK(3);
	MK.setemail("k.trojanowski@uksw.edu.pl",0);
	MojaKlasa MK2(MK);
	printf("%s\n", MK2.getemail(0));
	MK.setemail("m.mikolajczyk@uksw.edu.pl",0);
	printf("%s\n", MK2.getemail(0));
	return 0;
}

Program #7


#include <cstdio>
using namespace std;

class Bazowa {
public:
	Bazowa(int x) { printf("konstruktor - Bazowa: %i\n",x); }
	~Bazowa() { printf("destruktor - Bazowa\n"); }
};
class Skladowa1 {
public:
	Skladowa1(int x) { printf("konstruktor - Skladowa1: %i\n",x); }
	~Skladowa1() { printf("destruktor - Skladowa1\n"); }
};
class Skladowa2 {
public:
	Skladowa2(int x) { printf("konstruktor - Skladowa2: %i\n",x); }
	~Skladowa2() { printf("destruktor - Skladowa2\n"); }
};
class Skladowa3 {
public:
	Skladowa3(int x) { printf("konstruktor - Skladowa3: %i\n",x); }
	~Skladowa3() { printf("destruktor - Skladowa3\n"); }
};
class Skladowa4 {
public:
	Skladowa4(int x) { printf("konstruktor - Skladowa4: %i\n",x); }
	~Skladowa4() { printf("destruktor - Skladowa4\n"); }
};
class Pochodna1: public Bazowa {
	Skladowa1 s1;
	Skladowa2 s2;
public: 
	Pochodna1(int x): s2(4), s1(5), Bazowa(6) { printf("konstruktor - Pochodna1: %i\n",x); }
	~Pochodna1() { printf("destruktor - Pochodna1\n"); }
};
class Pochodna2: public Pochodna1 {
	Skladowa3 s3;
	Skladowa4 s4;
public: 
	Pochodna2(int x): s3(1), Pochodna1(2), s4(3) { printf("konstruktor - Pochodna2: %i\n",x); }
	~Pochodna2() { printf("destruktor - Pochodna2\n"); }
};
int main() { 
	Pochodna2 p2(0); 
	printf("======================\n");
	return 0;
}

Program #8


#include <cstdio>
using namespace std;

class Bazowa {
public:
    virtual int fun() { 
        printf("Bazowa: metoda fun\n"); 
        return 0; 
    }
    virtual int fun(char *a) { 
        printf("Bazowa: %s\n",a); 
        return 0;
    }
};
class Pochodna3: public Bazowa {
    public:
    int fun() {  
        printf("Pochodna3: metoda fun\n"); 
        return 0; 
    }
};
int main(int argc, char *argv[]) {
    Pochodna3 p3;
    Bazowa *pb;
    pb = &p3;    // rzutowanie w górę
    pb->fun("Asta la vista");
    pb->fun();
    pb->Bazowa::fun();
    return 0;
}

Program #9


#include <cstdio>
using namespace std;

class Bazowa {
public:
    virtual ~Bazowa() { 
        printf("%s\n","~Bazowa"); 
    }
};
class Pochodna3: public Bazowa {
public:
    ~Pochodna3() { 
        printf("%s\n","~Pochodna3"); 
    }
};

int main(int argc, char *argv[])
{
    Bazowa *bp = new Pochodna3();
    delete bp;	// jaki napis pojawi się w oknie?
    return 0;
}

Program #10


#include <cstdio>
using namespace std;

class Integer {
      int i;
public:
    Integer(int ii): i(ii) { printf("%i\n",i); }
    Integer& operator+=(const Integer& rv) {
                i += rv.i;
                return *this;
    }
    const Integer operator+(const Integer& rv) {
                return Integer(i+rv.i);
    }
    int get_i() { return i; }
};
      
int main(int argc, char *argv[])
{
    Integer I(1), J(2), K(3);
    I += J + K;
    printf("%i\n",I.get_i());

	return 0;
}

Program #11


#include <cstdio>
#include <cstring>
#include <cassert>
using namespace std;

class Tablica {
	int rozm;
	int *wsk;
public:
	Tablica( int = 10 );
	Tablica( const Tablica& );
	~Tablica();
	int rozmiar(void) const {return rozm; }
	const Tablica &operator=( const Tablica& );
	bool operator==( const Tablica& );
	int &operator[]( int );
	const int &operator[]( int ) const;
};

Tablica::Tablica(int r): rozm(r) {
	wsk = new int[rozm];
}
Tablica::Tablica( const Tablica& T): rozm(T.rozm) {
	wsk = new int[rozm];
	memcpy(wsk,T.wsk,rozm*sizeof(int));
}
Tablica::~Tablica() {
	delete []wsk;
}
const Tablica &Tablica::operator=( const Tablica& T) {
	if (rozm != T.rozm) {
		delete []wsk;
		wsk = new int[rozm=T.rozm];
	};
	memcpy(wsk,T.wsk,rozm*sizeof(int));
	return *this;
}
bool Tablica::operator==( const Tablica& T) {
	if (rozm != T.rozm)
		return false;
	else
		return !(memcmp(wsk,T.wsk,rozm*sizeof(int)));
}
int &Tablica::operator[]( int i) {
	assert (0 < = i && i < rozm);
	return wsk[i];
}
// operator dla obiektów zadeklarowanych jako const
const int &Tablica::operator[]( int i) const {
	assert (0 <= i && i < rozm);
	return wsk[i];
}
int main(int argc, char *argv[])
{
	Tablica Tab1(5), Tab2;
	for (int i=0; i<Tab1.rozmiar(); i++)
		Tab1[i] = i;
	Tab2 = Tab1;
	assert(Tab2 == Tab1);
	return 0;
}

Program #12


#include <cstdio>
#include <typeinfo>
using namespace std;

class Integer {
     int i;
public:
     Integer(int ii): i(ii) {}
     bool operator< (const Integer& rv) const 
       {
                return i < rv.i;
       }
     bool operator>(const Integer& rv) const 
       {
                return i > rv.i;
       }
};

template 
T wiekszy(const T& k1, const T& k2) {
                printf("Szablon dla: %s\n",typeid(k1).name());
                return k1 < k2 ? k2 : k1 ;
}
double wiekszy(const double& d1, const double& d2) {
                printf("Dla double: %s\n",typeid(d1).name());
                return d1 > d2 ? d2 : d1 ;
}

int main() {
	int a, b=1, c=0;
	a = wiekszy(b,c);

	char d, e=1, f=0;
	d = wiekszy(e,f);

	double x, y=0.3, z=2.14;
	x = wiekszy(y,z);

	Integer I1(0), I2(1), I3(2);
	I1 = wiekszy(I2, I3);

	return 0;
}

Program #13

main.cpp


#include <cstdio>
#include "wyklad13b.h"
using namespace std;

int main() {
	const int a=50;
	Tablica<int, 100> Tab1;
	Tablica<double,a> Tab2;

	for (int i=0;i<100;i++) {
		Tab1[i] = i;
		Tab2[i] = 0;
	}
	return 0;
}

wyklad13b.h


#include <cstdio>
using namespace std;

#ifndef wyklad13b_h
#define wyklad13b_h

template <typename T, int rozmiar>
class Tablica {
	T A[rozmiar];
public:
	T& operator[](int index) ;
};

template <typename T, int rozmiar>
T& Tablica<T,rozmiar>::operator[](int index) 
{
	if (index>=rozmiar || index<0)
		return A[0];
	else
		return A[index];
}

#endif

wyklad13b.cpp


#include "wyklad13b.h"
using namespace std;