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:
1) w środowisku Visual Studio 2017 Enterprise zainstalowanym w pracowniach lab.:
we właściwościach projektu wybrać w opcji „Właściwości konfiguracji | Konsolidator | System | Podsystem” wartość „Konsola”:
2) w środowisku Visual Studio Community:
w menu wybrać „Narzędzia -> Opcje” i w otwartym oknie zgasić znacznik przy pozycji „automatycznie zamknij konsolę zatrzymaniu debugowania”:
Program #1
#include <stdio.h>
int silnia(int x)
{
int i, wynik = 1;
for(i = 2; i < = x; i++)
wynik *= i;
return wynik;
}
int main() {
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