Od Informacji do Wiedzy

#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();
}

#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
}

#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;
}

#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;
}

#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;
}

#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;
}

#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;
}

#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;
}