Laboratoria nr 14 program nr 2

Pliki tekstowe i binarne. Operacje na plikach tekstowych.

Przyjmijmy, że jest dostępny plik tekstowy txt np. example.txt do którego, z procesu przetwarzania tekstu ze stron internetowych, co 10 minut poprzez Wi-fi zapisywane są dane w postaci łańcuchów znaków do wybranego pliku na serwerze. Przykładowa zawartość tego pliku została pokazana poniżej.

example.txt

s1 s2 s3
s4 s5 s6

Należy napisać program który odczyta zawartość podanego pliku oraz odpowiednio go przetworzy. Przetworzenie polega na obliczeniu i podaniu dla użytkownika:

– ilości linii znajdujących się w pliku,

– ilości liter bez spacji,

– ilości liter ze spacjami

– ilości wyrażeń w postaci słów (tokenów) znajdujących się w pliku.

Przykładowy zrzut z działającego programu przedstawiono poniżej na rysunku 1. Zebrane dane mają zostać, oprócz wyświetlenia ich na standardowym wyjściu konsoli, zapisane do oddzielnego pliku np. save.txt.

image

Rysunek 1. Zrzut działającego programu.

Szkielet przykładowej aplikacji został umieszony poniżej. Szkielet ten zawiera elementy które należy odpowiednio uzupełnić. Oczywiście można zaproponować własne, oryginalne rozwiązania. Poszczególne informacje dotyczące zebranych statystyk z przetworzonego pliku mają zostać umieszczone w strukturze. Z tego względu należy zaprojektować odpowiednie funkcje do wprowadzania oraz wyprowadzania danych tej struktury.

#include "stdafx.h"
#include <iostream>
#include <string>

// Biblioteka dostarczajaca interfejs do zapisu/odczytu danych do pliku
// @see http://www.cplusplus.com/reference/iostream/fstream/
#include <fstream>

using namespace std;

// Struktura przechowujaca informacje o zebranych ststatystychach z analizowanego tekstu
struct statStr {
	std::string text;
	int cLine;
	int ???;
	int cLetter;
	int ???;
};

/**
	Prototyp funkcji do obliczania ilosci liter wraz ze spacjami
*/
int cSpaceLetter(???);

/**
	Prototyp funkcji do obliczania ilosci liter bez spacji
*/
int ???(string s);

/**
	Prototyp funkcji do obliczania ilosci wyrazen
*/
int cToken(????);

/**
	Prototyp funkcji do pokazywania zebranych i zapisanych w strukturze ststystyk
	@note :: UWAGA prosze zastosowac zapis bez modyfikatora const i referencji 
	@note :: UWAGA jesli zastosuja Panstwo modyfikator const i referencje to 
				prosze wyjasnic do czego one sluza (jak dzialaja)
*/
void showStatStr(const statStr &s);

/**
	Prototyp funkcji do zapisywania zebranych i zapisanych w strukturze ststystyk do pliku
	@note :: UWAGA prosze zastosowac zapis bez modyfikatora const i referencji 
	@note :: UWAGA jesli zastosuja Panstwo modyfikator const i referencje to 
				prosze wyjasnic do czego one sluza (jak dzialaja)
*/
void saveStat(const statStr &s);

/**
	Program glowny do prezentujacy mozliwosc odczytywania oraz zapisywania
	danych do wybranych plikow w C++

	@author Marcin Mironczuk
*/
int main()
{
	string line;

	// Utworzenie "uchwytu" do obslugi wybranego pliku
	ifstream myfile;
	// Otwarcie pliku
	myfile.???(???);
  
	// Jesli udalo sie otworzyc plik to rozpocznij jego przetwarzanie
	if (myfile.is_open()) {
		
		double suma = 0;
		int i = 0;
		
		int ccLetter = 0;
		int ccToken = 0;
		int ccSpaceLetter = 0;

		string sLine;

		// Statyczne przydzielenie pamieci na strukture
		statStr s;

		// Przetwarzanie otwartego pliku w petli
		while (myfile.METODA_NADZORUJACA_CZY_OSIAGNIETO_KONIEC_PLIKU()) {
			// Pobranie lini z pliku i zapis do zmiennej line
			getline(???,???);
			
			// Uzycie zdefiniowanych plikow do przetwarzania linii tekstu
			// w celu zebrania odpowiednich ststystyk
			ccLetter += ???(line);
			ccToken += ???;
			??? += cSpaceLetter(line);

			sLine += line + " ";

			i++;
		}
		
		s.cLetter = ???;
		s.??? = i;
		???;
		s.??? = ccToken;
		s.??? = ???;

		// Pokazanie statystyk na wyjsciu konsolii
		showStatStr(s);
		
		// Zapis statystyk do pliku
		saveStat(s);

		// Zamkniecie pliku
		myfile.close();
	} else {
		// Jesli nie udalo sie otworzyc pliku to wyswietl odpowiedni komunikat dla uzytkownika
		cout << "Nieudana proba otwarcia pliku";
	}

	cin.get();

	return 0;
}

int cSpaceLetter(string s) {
	// Algorytm
}

int cLetter(string s) {
	// Algorytm
}

int cToken(string s) {
	// Algorytm
}

void showStatStr(const statStr &s) {
	// Algorytm pokazania pol struktury
}

void saveStat(const statStr &s) {
	ofstream myfile;
	myfile.METODA_DO_OTWIERANIA_PLIKU ("???");

	myfile << "Zebrane statystyki.\n";
	myfile << "Ilosc przetworzonych linii: " << ??? << endl;
	???
	???
	myfile << "Ilosc wyrazen w pliku: " << ??? << endl;
	???;

	myfile.ZAMKNIECIE_PLIKU();
}

Laboratoria nr 14 program nr 1

Pliki tekstowe i binarne. Operacje na plikach tekstowych.

Przyjmijmy, że jest dostępny plik tekstowy txt np. example.txt do którego, z procesu pomiarowego napięcia, co 10 minut poprzez Wi-fi zapisywane są dane pomiarowe. Przykładowa zawartość tego pliku została pokazana poniżej.

example.txt

12.3

12.4

12.3

11.98

11.93

12.3

12.5

12.5

Należy napisać program który odczyta zawartość podanego pliku, wyświetli wyniki pomiarów napięcia na standardowe wyjście konsoli oraz obliczy i poda użytkownikowi wartość średnią napięcia (wartość średnia napięcia ma być obliczana za pomocą funkcji). Plik pomiarowy może zawierać dowolną ilość zarejestrowanych wartości napięć.

Szkielet przykładowej aplikacji został umieszony poniżej. Szkielet ten zawiera elementy które należy odpowiednio uzupełnić. Oczywiście można zaproponować własne, oryginalne rozwiązania.

#include "stdafx.h"

/**
	@note :: Prosze zapoznac sie z nizej podanymi bibliotekami
*/
#include <iostream>
#include <sstream>
#include <fstream>
#include <string>

using namespace std;

/**
	Prototyp funkcji do obliczenia sredniej z pomiarow
*/
double sampleMean(???, ???, ... ???);

/**
	Program C/C++ demonstrujacy mozliwosc pobierania danych z pliku
	w raz z dodatkowym przetwarzaniem tych danych.Przetwarzanie polega
	na obliczeniu wartosci sredniej z pomiarow zapisanych w pobranym pliku.

	@author Marcin Mironczuk
*/
int main()
{
	// Zmienna tymczasowa do przechowywania odczytanej lini z pliku
	string line;

	// Uchwyt do pliku
	ifstream myfile;
	// Otworzenie pliku
	myfile.METODA_DO_OTWERANIA_PLIKU(???);
  
	// Wykonanie zadanego algorytmu do przetwarzania zawartosci pliku
	if (myfile.is_open()) {
		
		double suma = 0;
		int i = 0;

		// Przejzenie zawartosci pliku w petli
		while (myfile.METODA_NADZORUJACA_CZY_OSIAGNIETO_KONIEC_PLIKU()) {
			// Pobranie lini danych
			getline(???,line);
			
			// Pierwszy sposob rzutowania C++
			std::istringstream stm;
			stm.str(line);
			
			// Zmienna do ktorej bedzie przypisywana wartosc z rzutowania 
			double d1;
			stm >> ???;

			// Drugi sposob rzutowania specyficzny dla C
			// Zmienna do ktorej bedzie przypisywana wartosc z rzutowania 
			double d2;
			d2 = FUNCKJA_C_SLUZACA_DO_RZUTOWANIA(line.METODA_DO_PRZEKSZTALCENIA_LANCUCHA_DO_TABLICY_W_STYLU_C());
					
			// Wyswetlenie wartosci
			cout << ??? << endl;
			cout << ??? << endl;
			cout << ??? << endl;

			// Sumowanie zapisanych wartosci
			???;
			i++;
		}
		
		// Wykorzystanie funkcji do obliczenia sredniej z pomiarow ktorych wartosci zostaly zapisane
		// w pliku i wyzej przetworzone
		cout << "Srednia z zarejestrowanych pomiarow wynosi: " << ??? << endl;

		// Zamkniecie pliku
		myfile.close();
	} else {
		// Informacja uzytkownika w przypadku gdy nie udalo sie otworzyc pliku
		cout << "Proba otworzenia pliku nie powiodla sie";
	}

	cin.get();

	return 0;
}

double sampleMean(???) {
	// Algorytm do obliczania sredniej
}

Konferencja BDAS’11

Zakończyła się kolejna edycja konferencji BDAS’11. Wspaniała impreza oraz niepowtarzalna atmosfera. Zachęcam do uczestniczenia w następnych edycjach ludzi którzy jeszcze nie są pewni – naprawdę warto. Niezbędne informacje na temat konferencji jak i materiały prezentowane na sesjach plakatowych jak i planarnych można odnaleźć na stronie konferencji http://zti.aei.polsl.pl/bdas.

Laboratoria nr 13 program nr 2

Przekazywanie argumentów do funkcji przez wartość i referencje. Rekurencyjne wywołanie funkcji. Argumenty funkcji main.

UWAGA :: Proszę się zapoznać dokładnie z programem przedstawionym w wpisie  Laboratoria nr 13 program nr 1 zanim Państwo przystąpią do analizy niniejszego rozwiązania. Przykład ten jest rozszerzoną wersją wcześniejszego programu, dla osób które chcą poznać trochę więcej C++. Zachęcam do zgłębiania meandrów C++. Ewentualne pytania osób zainteresowanych zostaną omówione na zajęciach.

#include "stdafx.h"
#include <string>
#include <iostream>

using namespace std;

/**
	Podstawowa struktura do przetwarzania w programie
*/
struct statStr {
	std::string uName;
	int cLetter;
	int cToken;
};

/**
	Prototyp funkcji do uzupelniania struktury
	Struktura przekazywana jest przez referencje a nie wartosc.
	Jesli ktoras grupa chce korzystac z tego rozwiazania, to prosze podac
	uzasadnienie tego zabiegu oraz tego jak takie przekazywanie dziala.
	Proponuje zastosowania przekazywania przez wartosc, ktore latwiej jest na poczatku zrozumiec.
*/
void fillStr(statStr &sStr);

/**
	Prototyp funkcji do uzupelniania struktury
	Struktura przekazywana jest przez wskaznik a nie wartosc.
	Jesli ktoras grupa chce korzystac z tego rozwiazania, to prosze podac
	uzasadnienie tego zabiegu oraz tego jak takie przekazywanie dziala.
	Proponuje zastosowania przekazywania przez wartosc, ktore latwiej jest na poczatku zrozumiec.
	@note :: funkcja przeciazona
*/
void fillStr(statStr *sStr);

/**
	Prototyp funkcji do pokazywania elementow (pol) struktury.
	Struktura przekazywana jest przez referencje a nie przez wartosc.
	Do czego sluzy modyfikator const w zapisie w przypadku gdy przekazujemy strukture przez referencje?
	Czy taki modyfikator jest potrzebny w przypadku przekazywania przez wartosc?
	Jesli ktoras grupa chce korzystac z tego rozwiazania, to prosze podac
	uzasadnienie tego zabiegu oraz tego jak takie przekazywanie dziala.
	Proponuje zastosowania przekazywania przez wartosc, ktore latwiej jest na poczatku zrozumiec.
*/
void showStr(const statStr &sStr);

/**
	Prototyp funkcji do pokazywania elementow (pol) struktury.
	Struktura przekazywana jest przez referencje a nie przez wartosc.
	Do czego sluzy modyfikator const w zapisie w przypadku gdy przekazujemy strukture przez referencje?
	Czy taki modyfikator jest potrzebny w przypadku przekazywania przez wartosc?
	Jesli ktoras grupa chce korzystac z tego rozwiazania, to prosze podac
	uzasadnienie tego zabiegu oraz tego jak takie przekazywanie dziala.
	Proponuje zastosowania przekazywania przez wartosc, ktore latwiej jest na poczatku zrozumiec.
	@note :: funkcja przeciazona
*/
void showStr(const statStr *sStr);

/**
	Prototy funkcji do laczenia pol struktury.
	Struktury przekazywane sa przez referencje a nie przez wartosc.
	Do czego sluzy modyfikator const w zapisie w przypadku gdy przekazujemy strukture przez referencje?
	Czy taki modyfikator jest potrzebny w przypadku przekazywania przez wartosc?
	Jesli ktoras grupa chce korzystac z tego rozwiazania, to prosze podac
	uzasadnienie tego zabiegu oraz tego jak takie przekazywanie dziala.
	Proponuje zastosowania przekazywania przez wartosc, ktore latwiej jest na poczatku zrozumiec.
*/
statStr joinStr(const statStr &sStr1, const statStr &sStr2);

/**
	UWAGA !!!
	Znaki ? trzeba odpowiednio czyms zastapic, aby program sie skompilowal
	Prototyp funkcji do zrealizowania zadania polegajacego na zlaczeniu struktur,
	bez zwracania struktury jako wyniku.
*/
void joinStr(? , ... , ?);

/**
	Prototyp funkcji do zliczania ilosci znakow w podanym lancuhcu
*/
int cLetter(string s);

/**
	Prototyp funkcji do zliczania ilosci wyrazen w podanym lancuchu
*/
int cToken(string s);

/**
	Program prezentujacy mozliwosc wykorzystania funkcji operujacych
	na zdefiniowanej strukturze z dodatkowym rozwiazaniem polegajacym
	na dynamicznej alokacji pamieci na strukture.

	@author Marcin Mironczuk
*/
int main()
{
	using namespace std;

	// Tworzenie zmiennych o typie statStr (struktura)
	statStr s1, s2;
	
	// Tworzenie zmiennej przechowujacej informacje z obu ww. struktur
	statStr sumaStr;

	// Uzupelnianie struktur
	fillStr(s1);
	fillStr(s2);

	std::cout << std::endl;

	// Pokazanie zawartosci struktur
	showStr(s1);
	showStr(s2);

	// Polaczenie struktur
	sumaStr = joinStr(s1, s2);

	// Pokazanie zawartosci struktury polaczonej
	showStr(sumaStr);

	/**
		Zawansowane uzycie struktur z alokacja dynamiczna pamieci
	*/
	statStr *s = new statStr;

	fillStr(s);
	showStr(s);

	// Zwolnienie przydzielonej pamieci
	delete s;

	std::cin.get();
	std::cin.get();

	return 0;
}

void fillStr(statStr &sStr) {
	std::string temp;
	
	int countLetter = 0;
	int countToken = 0;

	std::cout << "Podaj imie i nazwisko: " << std::endl;
	getline(std::cin, sStr.uName);

	std::cout << "Podaj lancuch do wprowadzenia: " << std::endl;
	getline(std::cin, temp);
	
	countLetter = cLetter(temp);
	countToken = cToken(temp);

	sStr.cLetter = countLetter;
	sStr.cToken = countToken;
}

void fillStr(statStr *sStr) {
	std::string temp;
	
	int countLetter = 0;
	int countToken = 0;

	std::cout << "Podaj imie i nazwisko: " << std::endl;
	getline(std::cin, sStr->uName);

	std::cout << "Podaj lancuch do wprowadzenia: " << std::endl;
	getline(std::cin, temp);
	
	countLetter = cLetter(temp);
	countToken = cToken(temp);

	sStr->cLetter = countLetter;
	sStr->cToken = countToken;
}

void showStr(const statStr &sStr) {
	std::cout << "Podane imie i nazwisko to: " << sStr.uName << std::endl;
	std::cout << "Ilosc znakow w wprowadzonym lancuchu to: " << sStr.cLetter << std::endl;
	std::cout << "Ilosc wyrazen w wprowadzonym lancuchu to: " << sStr.cToken << std::endl;
	std::cout << std::endl;
}

void showStr(const statStr *sStr) {
	std::cout << "Podane imie i nazwisko to: " << sStr->uName << std::endl;
	std::cout << "Ilosc znakow w wprowadzonym lancuchu to: " << sStr->cLetter << std::endl;
	std::cout << "Ilosc wyrazen w wprowadzonym lancuchu to: " << sStr->cToken << std::endl;
	std::cout << std::endl;
}

statStr joinStr(const statStr &sStr1, const statStr &sStr2) {
	// Algorytm laczenia pol struktury
}

void joinStr(?, ..., ?) {
	// Algorytm laczenia struktur
}

int cLetter(string s) {
	return s.length();
}

int cToken(string s) {
	// Algorytm zaimplementowany na wczesniejszych zajeciach

	return 0;
}

Laboratoria nr 13 program nr 1

Przekazywanie argumentów do funkcji przez wartość i referencje. Rekurencyjne wywołanie funkcji. Argumenty funkcji main.

#include "stdafx.h"
#include <string>
#include <iostream>

using namespace std;

/**
	Podstawowa struktura do przetwarzania w programie
*/
struct statStr {
	std::string uName;
	int cLetter;
	int cToken;
};

/**
	Prototyp funkcji do uzupelniania struktury
	Struktura przekazywana jest przez referencje a nie wartosc.
	Jesli ktoras grupa chce korzystac z tego rozwiazania, to prosze podac
	uzasadnienie tego zabiegu oraz tego jak takie przekazywanie dziala.
	Proponuje zastosowania przekazywania przez wartosc, ktore latwiej jest na poczatku zrozumiec.
*/
void fillStr(statStr &sStr);

/**
	Prototyp funkcji do pokazywania elementow (pol) struktury.
	Struktura przekazywana jest przez referencje a nie przez wartosc.
	Do czego sluzy modyfikator const w zapisie w przypadku gdy przekazujemy strukture przez referencje?
	Czy taki modyfikator jest potrzebny w przypadku przekazywania przez wartosc?
	Jesli ktoras grupa chce korzystac z tego rozwiazania, to prosze podac
	uzasadnienie tego zabiegu oraz tego jak takie przekazywanie dziala.
	Proponuje zastosowania przekazywania przez wartosc, ktore latwiej jest na poczatku zrozumiec.
*/
void showStr(const statStr &sStr);

/**
	Prototy funkcji do laczenia pol struktury.
	Struktury przekazywane sa przez referencje a nie przez wartosc.
	Do czego sluzy modyfikator const w zapisie w przypadku gdy przekazujemy strukture przez referencje?
	Czy taki modyfikator jest potrzebny w przypadku przekazywania przez wartosc?
	Jesli ktoras grupa chce korzystac z tego rozwiazania, to prosze podac
	uzasadnienie tego zabiegu oraz tego jak takie przekazywanie dziala.
	Proponuje zastosowania przekazywania przez wartosc, ktore latwiej jest na poczatku zrozumiec.
*/
statStr joinStr(const statStr &sStr1, const statStr &sStr2);

/**
	Prototyp funkcji do zliczania ilosci znakow w podanym lancuhcu
	@todo :: Dla zaintersowanych - sprawdzenie co to jest przeciazanie funkcji
	@todo :: Alterantywnie mozna napisac funkcje przetwarzajaca tablice znakow.
	@todo :: Dla zaintersowanych - Tworzenie przeciazonej wersji funkcji cLetter pobierajaca jako argument tablice znakow
*/
int cLetter(string s);

/**
	Prototyp funkcji do zliczania ilosci wyrazen w podanym lancuchu
	@todo :: Alterantywnie mozna napisac funkcje przetwarzajaca tablice znakow.
	@todo :: Dla zaintersowanych - sprawdzenie co to jest przeciazanie funkcji
	@todo :: Dla zaintersowanych - Tworzenie przeciazonej wersji funkcji cToken pobierajaca jako argument tablice znakow
*/
int cToken(string s);

/**
	Program prezentujacy mozliwosc wykorzystania funkcji operujacych
	na zdefiniowanej strukturze.

	@author Marcin Mironczuk
*/
int main()
{
	using namespace std;

	// Tworzenie zmiennych o typie statStr (struktura)
	statStr s1, s2;
	
	// Tworzenie zmiennej przechowujacej informacje z obu ww. struktur
	statStr sumaStr;

	// Uzupelnianie struktur
	fillStr(s1);
	fillStr(s2);

	std::cout << std::endl;

	// Pokazanie zawartosci struktur
	showStr(s1);
	showStr(s2);

	// Polaczenie struktur
	sumaStr = joinStr(s1, s2);

	// Pokazanie zawartosci struktury polaczonej
	showStr(sumaStr);

	std::cin.get();
	std::cin.get();

	return 0;
}

void fillStr(statStr &sStr) {
	std::string temp;
	
	int countLetter = 0;
	int countToken = 0;

	std::cout << "Podaj imie i nazwisko: " << std::endl;
	getline(std::cin, sStr.uName);

	std::cout << "Podaj lancuch do wprowadzenia: " << std::endl;
	getline(std::cin, temp);
	
	countLetter = cLetter(temp);
	countToken = cToken(temp);

	sStr.cLetter = countLetter;
	sStr.cToken = countToken;
}


void showStr(const statStr &sStr) {
	std::cout << "Podane imie i nazwisko to: " << sStr.uName << std::endl;
	std::cout << "Ilosc znakow w wprowadzonym lancuchu to: " << sStr.cLetter << std::endl;
	std::cout << "Ilosc wyrazen w wprowadzonym lancuchu to: " << sStr.cToken << std::endl;
	std::cout << std::endl;
}

statStr joinStr(const statStr &sStr1, const statStr &sStr2) {
	// Algorytm sumowania pol przekazywanych struktur
	statStr s;
	return s;
}


int cLetter(string s) {
	return s.length();
}

int cToken(string s) {
	// Algorytm zaimplementowany na wczesniejszych zajeciach

	return 0;
}

Laboratoria nr 12 program nr 2

Funkcje, ogólna struktura funkcji. Umieszczanie definicji funkcji w programie. Zmienne lokalne i globalne. Zasięg i widzialność identyfikatorów.

#include "stdafx.h"
#include <iostream>
#include <cstring>
 
// Stale okreslajace wielkosc zalokowanej pamieci dla wykorzystywanych tablic
const int ArrSize = 50;
const int tempArrSize = 50;

int getTokenCout(const char *str);

/**
*
* Program Główny prezentujący funckje C++ wyprowadzania treści na wyjście konsoli.
* Trzy strategie (szkielety) algorytmow do zliczania ilosci slow (tokenow) w podanym przez
* uzytkownika lancuchu znakow.Prosze zwrocic uwage na interpretacje znaku spacji. Algorytmy
* w najprostszej postaci nie chronia przed podwojnymi spacjami. Mozna to wykryc poprzez wprowadzenie
* nastepujacego lancucha znakow: "1  2  3 "
*
* @author Marcin Mirończuk
*
*/
int main()
{
    // Tablica przechowujaca lancuch podany przez uzytkownika
    char slowa[ArrSize];
 
    // Wprwadzanie lancucha znakow
    std::cout << "Podaj slowa: " << std::endl;
    std::cin.getline(slowa, ArrSize);
 
	std::cout << "Ilosc wprowadzonych slow to: " << getTokenCout(slowa) << std::endl;

 
    std::cin.get();
    std::cin.get();
 
    return 0;
}

int getTokenCout(const char *str) {
	// Ustawienie zmiennych tymczasowych
    int k = 0;
    int iloscSlow = 0;
 
    // Przetwarzanie wprowadzonego lanucha znakow
    for(int i = 0; i < strlen(str); i++) {
        // Tymczasowa tablic do przechowywania znakow a nastepnie lanucha znakow w postaci osobnych tokenow
        char temp[tempArrSize];
 
        // Najprostszy sposob wykrywania spacji oraz konca lancucha
        if(isspace(str[i]) || str[i+1] == '\0') {
            temp[k] = '\0';
 
            iloscSlow++;
            k = 0;
            temp[k] = '\0';
        } else {
            // Zapis znaku to tablicy tymczasowej
            temp[k] = str[i];
            k++;
        }
    }

	return iloscSlow;
}

Laboratoria nr 12 program nr 2

Funkcje, ogólna struktura funkcji. Umieszczanie definicji funkcji w programie. Zmienne lokalne i globalne. Zasięg i widzialność identyfikatorów.

#include "stdafx.h"
#include <iostream>
#include <cstring>
 
// Stale okreslajace wielkosc zalokowanej pamieci dla wykorzystywanych tablic
const int ArrSize = 50;
const int tempArrSize = 50;

// Funkcja zliczająca ilość słów w podanym łańcuchu znaków
int getTokenCout(const char *str);

/**
*
* Program Główny prezentujący funckje C++ wyprowadzania treści na wyjście konsoli.
* Demonstracja przeniesienia strategii nr. 1 z Laboratoria nr 10 program nr 2 (http://profind.pl/2011/05/18/laboratoria-nr-10-program-nr-2/) do funkcji.
* Prosze zwrocic uwage na interpretacje znaku spacji. Algorytmy w dalszym ciągu jest
* w najprostszej postaci nie chronia przed podwojnymi spacjami. Mozna to wykryc poprzez wprowadzenie
* nastepujacego lancucha znakow: "1  2  3 "
*
* @author Marcin Mirończuk
*
*/
int main()
{
    // Tablica przechowujaca lancuch podany przez uzytkownika
    char slowa[ArrSize];
 
    // Wprwadzanie lancucha znakow
    std::cout << "Podaj slowa: " << std::endl;
    std::cin.getline(slowa, ArrSize);
 
	std::cout << "Ilosc wprowadzonych slow to: " << getTokenCout(slowa) << std::endl;

 
    std::cin.get();
    std::cin.get();
 
    return 0;
}

// Modyfikator const - zabezpiecznie przed modyfikacja wartosci wskazanej
int getTokenCout(const char *str) {
	// Ustawienie zmiennych tymczasowych
    int k = 0;
    int iloscSlow = 0;
 
    // Przetwarzanie wprowadzonego lanucha znakow
    for(int i = 0; i < strlen(str); i++) {
        // Tymczasowa tablic do przechowywania znakow a nastepnie lanucha znakow w postaci osobnych tokenow
        char temp[tempArrSize];
 
        // Najprostszy sposob wykrywania spacji oraz konca lancucha
        if(isspace(str[i]) || str[i+1] == '\0') {
            temp[k] = '\0';
 
            iloscSlow++;
            k = 0;
            temp[k] = '\0';
        } else {
            // Zapis znaku to tablicy tymczasowej
            temp[k] = str[i];
            k++;
        }
    }

	return iloscSlow;
}

Laboratoria nr 12 program nr 1

Funkcje, ogólna struktura funkcji. Umieszczanie definicji funkcji w programie. Zmienne lokalne i globalne. Zasięg i widzialność identyfikatorów.

#include "stdafx.h"
#include <iostream>

// Funkcja inline
inline double square(double x) { return x*x;};

// Funkcja zachowujaca wartosc na ktora wskazuje wskaznik i zwracajaca nowy wynik
float square(float const * x);

// Modyfikacja wartosci pod adresem wskazywanym przez wskaznik i zwrocenie dodatkowo adresu modyfikowanej wartosci
float *psquare(float * x);

// Alternatywne do wskaznikow przekazywanie przez referencje
void square(float &x);

float psquare(float const &x);

/**
* Funkcje inline wystepuja w C++, C tej funckji nie posiada.
* Program demonstrujacy tworzenie, wywolywanie i dzialanie funkcji inline, jak i pozostalych funkcji
* @author Marcin Mironczuk
*/
int main()
{
	double a = 0;

	std::cout << "Podaj wartosc a: " << std::endl;
	std::cin >> a;
	std::cout << "Kwadrat liczby to: " << square(a) << std::endl;

	double *p1 = &a;

	std::cout << "Wartosc p1: " << *p1 << std::endl;
	std::cout << "Adres p1: " << p1 << std::endl;
	std::cout << "Adres a: " << &a << std::endl;

	float k = 2;
	float *p2 = &k;

	std::cout << "Wartosc k: " << square(p2) << std::endl;
	std::cout << "Wartosc k: " << *psquare(p2) << std::endl;
	std::cout << "Wartosc k po modyfikacji przez *psquare(): " << k << std::endl;
	
	square(k);
	std::cout << "Wartosc k po modyfikacji przez square(float &x): " << k << std::endl;
	std::cout << "Modyfikacja k poprzez psquare(float const &x): " << psquare(k) << std::endl;
	std::cout << "Wartosc k po modyfikacji przez psquare(float const &x): " << k << std::endl;

	std::cin.get();
	std::cin.get();

	return 0;
}

// zabezpiecznie przed modyfikacja wartosci wskazanej
float square(float const * x) {
	return (*x)*(*x);
};

float *psquare(float * x) {
	*x = (*x)*(*x);
	return x;
};

// Troche niebezpiecznie modyfikujemy przekazywana wartosc
void square(float &x) {
	x = x*x;
};

// Bardziej bezpieczny sposob
float psquare(float const &x) {
	return x*x;
}

Laboratoria nr 11 program nr 1

Struktury, odwołania do pól struktury, inicjalizacja zmiennej strukturalnej. Pola bitowe i unie.

#include "stdafx.h"
#include <string>
#include <iostream>

// Wielkosc ustalona tablicy do przechowywania snakow
const int snackCount = 3;

/**
*
* Program Główny prezentujący funckje C++ wyprowadzania treści na wyjście konsoli.
* Program prezentujacy zastosowania struktur w programowaniu
*
* @author Marcin Mirończuk
*
*/
int main()
{
	using namespace std;

	struct Batonik {
		std::string marka;
		float waga;
		int iloscKalori;
	};

	// Deklaracja tablicy przechowujacej struktury Batonik
	Batonik batoniki[snackCount];

	// Deklaracja i inicjalizacja wybranych struktur
	Batonik snack = {"Super chrupek" , 2.3, 350};
	Batonik superSnack = {"Super  mega chrupek" , 4.6, 700};
	Batonik megaSnack;

	megaSnack.marka = snack.marka + " " + superSnack.marka;
	megaSnack.waga = snack.waga + superSnack.waga;
	megaSnack.iloscKalori = snack.iloscKalori + superSnack.iloscKalori;

	// Dodanie batonikow do tablicy
	batoniki[0] = snack;
	batoniki[1] = superSnack;
	batoniki[2] = megaSnack;

	for(int i = 0; i < snackCount; i++) {
		std::cout << "Parametry batonika nr " << i+1 << " to: " << std::endl;
		std::cout <<  "- marka - " << batoniki[i].marka << std::endl;
		std::cout <<  "- waga - " << batoniki[i].waga << std::endl;
		std::cout <<  "- ilosc kalorii - " << batoniki[i].iloscKalori << std::endl;
	}

	/** Wersja z dynamiczna alokacja pamiei na struktur */

	// Zalokowanie pamieci na nowa strukture wypadkowa
	Batonik *dmegaSnack = new Batonik;

	dmegaSnack->marka = snack.marka + superSnack.marka;
	dmegaSnack->waga = snack.waga + superSnack.waga;
	dmegaSnack->iloscKalori = snack.iloscKalori + superSnack.iloscKalori;

	delete dmegaSnack;

	std::cin.get();

	return 0;
}

Laboratoria nr 10 program nr 2

Łańcuchy znaków. Inicjalizacja łańcucha znaków. Stała znakowa. Funkcje do wprowadzania i wyprowadzania znaków. Plik nagłówkowy string.h (cstring). Przykłady kodu w C/C++. Szkielet programu do wczytywania z konsoli mieszanego łańcucha znaków ze spacjami oraz segmentacji wprowadzonego łańcucha ze względu na występujące w nim spacje. Po segmentacji program ma wykonać zadane operacje na poszczególnych albo wszystkich elementach łańcucha.

#include "stdafx.h"
#include <iostream>
#include <cstring>

// Stale okreslajace wielkosc zalokowanej pamieci dla wykorzystywanych tablic
const int ArrSize = 50;
const int tempArrSize = 50;

/**
*
* Program Główny prezentujący funckje C++ wyprowadzania treści na wyjście konsoli.
* Trzy strategie (szkielety) algorytmow do zliczania ilosci slow (tokenow) w podanym przez
* uzytkownika lancuchu znakow.Prosze zwrocic uwage na interpretacje znaku spacji. Algorytmy
* w najprostszej postaci nie chronia przed podwojnymi spacjami. Mozna to wykryc poprzez wprowadzenie
* nastepujacego lancucha znakow: "1  2  3 "
*
* @author Marcin Mirończuk
*
*/
int main()
{
	// Tablica przechowujaca lancuch podany przez uzytkownika
	char slowa[ArrSize];

	// Wprwadzanie lancucha znakow
	std::cout << "Podaj slowa: " << std::endl;
	std::cin.getline(slowa, ArrSize);

	/**
	 * Strategia nr I - rozwiazanie podstawowe
	 *
	*/

	// Ustawienie zmiennych tymczasowych
	int k = 0;
	int iloscSlow = 0;
	
	// Przetwarzanie wprowadzonego lanucha znakow
	for(int i = 0; i < strlen(slowa); i++) {
		// Tymczasowa tablic do przechowywania znakow a nastepnie lanucha znakow w postaci osobnych tokenow
		char temp[tempArrSize];

		// Najprostszy sposob wykrywania spacji oraz konca lancucha
		if(isspace(slowa[i]) || slowa[i+1] == '\0') {
			temp[k] = '\0';
			
			iloscSlow++;
			k = 0;
			temp[k] = '\0';
		} else {
			// Zapis znaku to tablicy tymczasowej
			temp[k] = slowa[i];
			k++;
		}
	}
	
	std::cout << "Ilosc podanych slow: " << iloscSlow << std::endl;
	

	/**
	 * Strategia nr II - rozwiazanie rozszerzone na wskaznikach na lanuchy znakow
	 *
	*/

	// Deklaracja zmiennej do przechowywania ilosci wykrytych slow (tokenow)
	iloscSlow = 0;
	
	// Utworzenie stalego wskaznika na wprowadzony przez uzytkownika lancuch (ochrona przed modyfikacja)
	// Wksazanie pierwszego elementu tablicy slowa.
	const char *pslowa = slowa;

	// Iteracyjne przesowanie wskaznika 
	while(*pslowa) {
		if(isspace(*pslowa)) {
			iloscSlow++;
		}

		pslowa++;
	}
	
	iloscSlow++;

	std::cout << "Ilosc podanych slow: " << iloscSlow << std::endl;

	/**
	 * Strategia nr III - rozwiazanie rozszerzone z uzyciem tworzenie dynamicznej tablicy 
	 *                  do alokacji nowej pamieci na wczytany lanuch znakow. Wersja uproszczona.
	 *
	*/

	// Alokacja dynamiczna nowej z zalozenia mniejszej pamieci
	char *nslowa = new char[strlen(slowa) + 1];

	// Skopiowanie lanucha do nowej tablicy. 
	// @todo wczytywanie lancucha do tabicy slowa powinno odbywac sie w fukcji. Tablica slowa powinna byc tymczasowa
	strcpy(nslowa, slowa);

	// Zmienna przechowujaca ilosc slow
	iloscSlow = 0;
	
	// Przetwarzanie lanucha znakow
	for(int i = 0; i < strlen(nslowa); i++) {
		if(isspace(nslowa[i])) {
			iloscSlow++;
		}
	}

	// Zwolnienie przydzielonej pamieci
	delete [] nslowa;

	iloscSlow++;

	std::cout << "Ilosc podanych slow: " << iloscSlow << std::endl;
	

	std::cin.get();
	std::cin.get();

	return 0;
}