Slot Machine – Abordagem em C++ segundo o paradigma ADT

Nas últimas aulas de p.s.i estivemos a realizar uma ficha de trabalho na qual consistia criar um objecto segundo o paradigma de programação ADT.

Eu decidi criar uma slot machine.

Esta minha slot machine é um autêntico jogo de sorte, o qual consiste em acertar em vários tipos de combinações para ganhar créditos, que nos permitem continuar a jogar.

Que operações se podem realizar com este objecto?

• Gera um número aleatório para cada slot da slot machine.

• Mostra a slot machine.

• Verifica os créditos que temos e ao mesmo tempo verifica as combinações na mesma função.

O nome que vou definir à minha classe é Slot.

Classe :

Slot.h

#include <cstdlib>
#ifndef SLOT_H
#define SLOT_H
class Slot{
public:
	Slot();
	void PullTheLever();
	void ShowSlotMachine();
	void PlayTheGame();
	//prémios
	bool Jackpot();			// acertar em todas as slots
	bool DuasDiagonais();	// acertar em duas diagonais
	bool DuasVertical();	// acertar em duas verticais
	bool DuasHorizontal();	// acertar em duas horizontais
	bool HV();				// acertar numa horizontal e numa vertical
	bool DuasHV();			// acertar em duas verticais e em duas horizontais
	bool DHV();				// acertar numa diagonal numa vertical e numa horizontal
	bool Diagonal();		// acertar numa diagonal
	bool Vertical();		// acertar numa vertical
	bool Horizontal();		// acertar numa horizontal
private:
	int nslot[3][3];
};
#endif

Slot.cpp gera números aleatórios para cada slot, apresentando os valores obtidos através do desenho da slot machine e verifica os vários tipos de combinações possíveis:

Slot.cpp

#include <iostream>
#include "Slot.h"
using namespace std;
Slot::Slot(){
	PullTheLever();
}

void Slot::PullTheLever(){
	nslot[0][0] = rand()%9+1;
	nslot[0][1] = rand()%9+1;
	nslot[0][2] = rand()%9+1;
	nslot[1][0] = rand()%9+1;
	nslot[1][1] = rand()%9+1;
	nslot[1][2] = rand()%9+1;
	nslot[2][0] = rand()%9+1;
	nslot[2][1] = rand()%9+1;
	nslot[2][2] = rand()%9+1;
}

void Slot::ShowSlotMachine(){
	cout<<"*******************************"<<endl;
	cout<<"****     SLOT MACHINE      ****"<<endl;
	cout<<"*******************************"<<endl;
	cout<<"***     *****     *****     ***"<<endl;
	cout<<"***  "<< nslot[0][0]<<"  *****  "<<nslot[0][1]<<"  *****  "<<nslot[0][2]<<"  ***"<<endl;
	cout<<"***     *****     *****     ***"<<endl;
	cout<<"*******************************"<<endl;
	cout<<"***     *****     *****     ***"<<endl;
	cout<<"***  "<<nslot[1][0]<<"  *****  "<<nslot[1][1]<<"  *****  "<<nslot[1][2]<<"  ***"<<endl;
	cout<<"***     *****     *****     ***"<<endl;
	cout<<"*******************************"<<endl;
	cout<<"***     *****     *****     ***"<<endl;
	cout<<"***  "<<nslot[2][0]<<"  *****  "<<nslot[2][1]<<"  *****  "<<nslot[2][2]<<"  ***"<<endl;
	cout<<"***     *****     *****     ***"<<endl;
	cout<<"*******************************"<<endl;
	cout<<"*******************************"<<endl;
};

bool Slot::Jackpot(){
	int padrao = nslot[0][0];
	if(padrao==nslot[0][0] && padrao==nslot[0][1] && padrao==nslot[0][2] &&
	   padrao==nslot[1][0] && padrao==nslot[1][1] && padrao==nslot[1][2] &&
	   padrao==nslot[2][0] && padrao==nslot[2][1] && padrao==nslot[2][2])
		return true;
	else
		return false;
}

bool Slot::DuasDiagonais(){
	int padrao = nslot[0][0];
	if(padrao==nslot[0][0] && padrao==nslot[1][1] && padrao==nslot[2][2] &&
	   padrao==nslot[0][2] && padrao==nslot[1][1] && padrao==nslot[2][0])
		return true;
	else
		return false;
}

bool Slot::Vertical(){
	if((nslot[0][0] == nslot[1][0] && nslot[0][0]==nslot[2][0]) ||
	   (nslot[0][1] == nslot[1][1] && nslot[0][1]==nslot[2][1]) ||
	   (nslot[0][2] == nslot[1][2] && nslot[0][2]==nslot[2][2]))

		return true;
	else
		return false;
}

bool Slot::Horizontal(){
	if((nslot[0][0] == nslot[0][1] && nslot[0][0]==nslot[0][2]) ||
	   (nslot[1][0] == nslot[1][1] && nslot[1][0]==nslot[1][2]) ||
	   (nslot[2][0] == nslot[2][1] && nslot[2][0]==nslot[2][2]))

		return true;
	else
		return false;
}

bool Slot::Diagonal(){
	if((nslot[0][0] == nslot[1][1] && nslot[0][0] == nslot[2][2]) ||
	   (nslot[0][2] == nslot[1][1] && nslot[0][2] == nslot[2][0]))
		return true;
	else
		return false;
}

bool Slot::DHV(){
	if(((nslot[0][0] == nslot[0][1] && nslot[0][0]==nslot[0][2]) &&
	   (nslot[0][0] == nslot[1][0] && nslot[0][0]==nslot[2][0]) &&
	   (nslot[0][0] == nslot[1][1] && nslot[0][0] == nslot[2][2])) ||

       ((nslot[0][0] == nslot[0][1] && nslot[0][0]==nslot[0][2]) &&
	   (nslot[0][0] == nslot[1][0] && nslot[0][0]==nslot[2][0]) &&
	   (nslot[0][2] == nslot[1][1] && nslot[0][2] == nslot[2][0])) ||

       ((nslot[0][0] == nslot[0][1] && nslot[0][0]==nslot[0][2]) &&
	   (nslot[0][1] == nslot[1][1] && nslot[0][1]==nslot[2][1]) &&
	   (nslot[0][0] == nslot[1][1] && nslot[0][0] == nslot[2][2])) ||

	   ((nslot[0][0] == nslot[0][1] && nslot[0][0]==nslot[0][2]) &&
	   (nslot[0][1] == nslot[1][1] && nslot[0][1]==nslot[2][1]) &&
	   (nslot[0][2] == nslot[1][1] && nslot[0][2] == nslot[2][0])) ||

       ((nslot[0][0] == nslot[0][1] && nslot[0][0]==nslot[0][2]) &&
	   (nslot[0][2] == nslot[1][2] && nslot[0][2]==nslot[2][2]) &&
       (nslot[0][0] == nslot[1][1] && nslot[0][0] == nslot[2][2])) ||

       ((nslot[0][0] == nslot[0][1] && nslot[0][0]==nslot[0][2]) &&
	   (nslot[0][2] == nslot[1][2] && nslot[0][2]==nslot[2][2]) &&
	   (nslot[0][2] == nslot[1][1] && nslot[0][2] == nslot[2][0])) ||

       ((nslot[1][0] == nslot[1][1] && nslot[1][0]==nslot[1][2]) &&
	   (nslot[0][0] == nslot[1][0] && nslot[0][0]==nslot[2][0]) &&
       (nslot[0][0] == nslot[1][1] && nslot[0][0] == nslot[2][2])) ||

       ((nslot[1][0] == nslot[1][1] && nslot[1][0]==nslot[1][2]) &&
	   (nslot[0][0] == nslot[1][0] && nslot[0][0]==nslot[2][0]) &&
	   (nslot[0][2] == nslot[1][1] && nslot[0][2] == nslot[2][0])) ||

       ((nslot[1][0] == nslot[1][1] && nslot[1][0]==nslot[1][2]) &&
	   (nslot[0][1] == nslot[1][1] && nslot[0][1]==nslot[2][1]) &&
       (nslot[0][0] == nslot[1][1] && nslot[0][0] == nslot[2][2])) ||

       ((nslot[1][0] == nslot[1][1] && nslot[1][0]==nslot[1][2]) &&
	   (nslot[0][1] == nslot[1][1] && nslot[0][1]==nslot[2][1]) &&
       (nslot[0][2] == nslot[1][1] && nslot[0][2] == nslot[2][0])) ||

       ((nslot[1][0] == nslot[1][1] && nslot[1][0]==nslot[1][2]) &&
	   (nslot[0][2] == nslot[1][2] && nslot[0][2]==nslot[2][2]) &&
       (nslot[0][0] == nslot[1][1] && nslot[0][0] == nslot[2][2])) ||

       ((nslot[1][0] == nslot[1][1] && nslot[1][0]==nslot[1][2]) &&
	   (nslot[0][2] == nslot[1][2] && nslot[0][2]==nslot[2][2]) &&
       (nslot[0][2] == nslot[1][1] && nslot[0][2] == nslot[2][0])) ||

       ((nslot[2][0] == nslot[2][1] && nslot[2][0]==nslot[2][2]) &&
	   (nslot[0][0] == nslot[1][0] && nslot[0][0]==nslot[2][0]) &&
       (nslot[0][0] == nslot[1][1] && nslot[0][0] == nslot[2][2])) ||

       ((nslot[2][0] == nslot[2][1] && nslot[2][0]==nslot[2][2]) &&
	   (nslot[0][0] == nslot[1][0] && nslot[0][0]==nslot[2][0]) &&
       (nslot[0][2] == nslot[1][1] && nslot[0][2] == nslot[2][0])) ||

       ((nslot[2][0] == nslot[2][1] && nslot[2][0]==nslot[2][2]) &&
	   (nslot[0][1] == nslot[1][1] && nslot[0][1]==nslot[2][1]) &&
       (nslot[0][0] == nslot[1][1] && nslot[0][0] == nslot[2][2])) ||

       ((nslot[2][0] == nslot[2][1] && nslot[2][0]==nslot[2][2]) &&
	   (nslot[0][1] == nslot[1][1] && nslot[0][1]==nslot[2][1]) &&
       (nslot[0][2] == nslot[1][1] && nslot[0][2] == nslot[2][0])) ||

       ((nslot[2][0] == nslot[2][1] && nslot[2][0]==nslot[2][2]) &&
	   (nslot[0][2] == nslot[1][2] && nslot[0][2]==nslot[2][2]) &&
       (nslot[0][0] == nslot[1][1] && nslot[0][0] == nslot[2][2])) ||

       ((nslot[2][0] == nslot[2][1] && nslot[2][0]==nslot[2][2]) &&
	   (nslot[0][2] == nslot[1][2] && nslot[0][2]==nslot[2][2]) &&
       (nslot[0][2] == nslot[1][1] && nslot[0][2] == nslot[2][0])))

		return true;
	else
		return false;
}

bool Slot::HV(){
	if(((nslot[0][0] == nslot[0][1] && nslot[0][0]==nslot[0][2]) &&
	   (nslot[0][0] == nslot[1][0] && nslot[0][0]==nslot[2][0])) ||

       ((nslot[0][0] == nslot[0][1] && nslot[0][0]==nslot[0][2]) &&
	   (nslot[0][1] == nslot[1][1] && nslot[0][1]==nslot[2][1])) ||

       ((nslot[0][0] == nslot[0][1] && nslot[0][0]==nslot[0][2]) &&
	   (nslot[0][2] == nslot[1][2] && nslot[0][2]==nslot[2][2])) ||

       ((nslot[1][0] == nslot[1][1] && nslot[1][0]==nslot[1][2]) &&
	   (nslot[0][0] == nslot[1][0] && nslot[0][0]==nslot[2][0])) ||

       ((nslot[1][0] == nslot[1][1] && nslot[1][0]==nslot[1][2]) &&
	   (nslot[0][1] == nslot[1][1] && nslot[0][1]==nslot[2][1])) ||

       ((nslot[1][0] == nslot[1][1] && nslot[1][0]==nslot[1][2]) &&
	   (nslot[0][2] == nslot[1][2] && nslot[0][2]==nslot[2][2])) ||

       ((nslot[2][0] == nslot[2][1] && nslot[2][0]==nslot[2][2]) &&
	   (nslot[0][0] == nslot[1][0] && nslot[0][0]==nslot[2][0])) ||

       ((nslot[2][0] == nslot[2][1] && nslot[2][0]==nslot[2][2]) &&
	   (nslot[0][1] == nslot[1][1] && nslot[0][1]==nslot[2][1])) ||

       ((nslot[2][0] == nslot[2][1] && nslot[2][0]==nslot[2][2]) &&
	   (nslot[0][2] == nslot[1][2] && nslot[0][2]==nslot[2][2])))

		return true;
	else
		return false;
}

bool Slot::DuasHorizontal(){
	if(((nslot[0][0] == nslot[0][1] && nslot[0][0]==nslot[0][2]) &&
	   (nslot[1][0] == nslot[1][1] && nslot[1][0]==nslot[1][2])) ||
	   ((nslot[0][0] == nslot[0][1] && nslot[0][0]==nslot[0][2]) &&
	   (nslot[2][0] == nslot[2][1] && nslot[2][0]==nslot[2][2])) ||
	   ((nslot[1][0] == nslot[1][1] && nslot[1][0]==nslot[1][2]) &&
	   (nslot[2][0] == nslot[2][1] && nslot[2][0]==nslot[2][2])))
		return true;
	else
		return false;
}

bool Slot::DuasVertical(){
	if(((nslot[0][0] == nslot[1][0] && nslot[0][0]==nslot[2][0]) &&
	   (nslot[0][1] == nslot[1][1] && nslot[0][1]==nslot[2][1])) ||
	   ((nslot[0][0] == nslot[1][0] && nslot[0][0]==nslot[2][0]) &&
	   (nslot[0][2] == nslot[1][2] && nslot[0][2]==nslot[2][2])) ||
	   ((nslot[0][1] == nslot[1][1] && nslot[0][1]==nslot[2][1]) &&
	   (nslot[0][2] == nslot[1][2] && nslot[0][2]==nslot[2][2])))
		return true;
	else
		return false;
}

bool Slot::DuasHV(){
	if((((nslot[1][0] == nslot[1][1] && nslot[1][0]==nslot[1][2]) &&
	   (nslot[2][0] == nslot[2][1] && nslot[2][0]==nslot[2][2])) &&
	   ((nslot[0][0] == nslot[1][0] && nslot[0][0]==nslot[2][0]) &&
	   (nslot[0][1] == nslot[1][1] && nslot[0][1]==nslot[2][1]))) ||

       (((nslot[1][0] == nslot[1][1] && nslot[1][0]==nslot[1][2]) &&
	   (nslot[2][0] == nslot[2][1] && nslot[2][0]==nslot[2][2])) &&
	   ((nslot[0][0] == nslot[1][0] && nslot[0][0]==nslot[2][0]) &&
	   (nslot[0][2] == nslot[1][2] && nslot[0][2]==nslot[2][2]))) ||

       (((nslot[1][0] == nslot[1][1] && nslot[1][0]==nslot[1][2]) &&
	   (nslot[2][0] == nslot[2][1] && nslot[2][0]==nslot[2][2])) &&
	   ((nslot[0][1] == nslot[1][1] && nslot[0][1]==nslot[2][1]) &&
	   (nslot[0][2] == nslot[1][2] && nslot[0][2]==nslot[2][2]))) ||

	   (((nslot[0][0] == nslot[0][1] && nslot[0][0]==nslot[0][2]) &&
	   (nslot[2][0] == nslot[2][1] && nslot[2][0]==nslot[2][2])) &&
	   ((nslot[0][0] == nslot[1][0] && nslot[0][0]==nslot[2][0]) &&
	   (nslot[0][1] == nslot[1][1] && nslot[0][1]==nslot[2][1]))) ||

       (((nslot[0][0] == nslot[0][1] && nslot[0][0]==nslot[0][2]) &&
	   (nslot[2][0] == nslot[2][1] && nslot[2][0]==nslot[2][2])) &&
	   ((nslot[0][0] == nslot[1][0] && nslot[0][0]==nslot[2][0]) &&
	   (nslot[0][2] == nslot[1][2] && nslot[0][2]==nslot[2][2]))) ||

	   (((nslot[0][0] == nslot[0][1] && nslot[0][0]==nslot[0][2]) &&
	   (nslot[2][0] == nslot[2][1] && nslot[2][0]==nslot[2][2])) &&
	   ((nslot[0][1] == nslot[1][1] && nslot[0][1]==nslot[2][1]) &&
	   (nslot[0][2] == nslot[1][2] && nslot[0][2]==nslot[2][2]))) ||

	   (((nslot[0][0] == nslot[0][1] && nslot[0][0]==nslot[0][2]) &&
	   (nslot[1][0] == nslot[1][1] && nslot[1][0]==nslot[1][2])) &&
	   ((nslot[0][0] == nslot[1][0] && nslot[0][0]==nslot[2][0]) &&
	   (nslot[0][1] == nslot[1][1] && nslot[0][1]==nslot[2][1]))) ||

	   (((nslot[0][0] == nslot[0][1] && nslot[0][0]==nslot[0][2]) &&
	   (nslot[1][0] == nslot[1][1] && nslot[1][0]==nslot[1][2])) &&
	   ((nslot[0][0] == nslot[1][0] && nslot[0][0]==nslot[2][0]) &&
	   (nslot[0][2] == nslot[1][2] && nslot[0][2]==nslot[2][2]))) ||

	   (((nslot[0][0] == nslot[0][1] && nslot[0][0]==nslot[0][2]) &&
	   (nslot[1][0] == nslot[1][1] && nslot[1][0]==nslot[1][2])) &&
	   ((nslot[0][1] == nslot[1][1] && nslot[0][1]==nslot[2][1]) &&
	   (nslot[0][2] == nslot[1][2] && nslot[0][2]==nslot[2][2]))))

		return true;
	else
		return false;
}

void menu(){
	cout<<endl<<"PREMIOS:"<<endl;
	cout<<"Jackpot 20 creditos"<<endl,
	cout<<"Duas horizontais e duas verticais 12 creditos"<<endl,
	cout<<"Duas horizontais 6 creditos"<<endl;
	cout<<"Duas verticais 6 creditos"<<endl;
	cout<<"Duas diagonais 6 creditos"<<endl;
	cout<<"Uma horizontal uma vertical e uma diagonal 6 creditos"<<endl;
	cout<<"Uma horizontal uma vertical 4 creditos"<<endl;
	cout<<"Uma diagonal 3 creditos"<<endl;
	cout<<"Uma horizontal 3 creditos"<<endl;
	cout<<"Uma verticalal 3 creditos"<<endl<<endl;
}

void Slot::PlayTheGame(){
	int credit=5;
	char op;
	menu();
	cout<<"Voce tem "<<credit<<" Creditos."<<endl;
	cout<<"Quer jogar Opção (y/n): ";cin>>op;

	if(op == 'y'){
	do{
		PullTheLever();
	    ShowSlotMachine();
	if(Jackpot()){
		cout << "Ganhou o Jackpot" << endl;
		credit=credit+20;
	}
	else 	if(DuasHV()){
				cout << "Ganhou o duas horrizontal e duas Vertical" << endl;
				credit=credit+12;
			}
			else	 if(DuasHorizontal()){
						cout << "Ganhou o DuasHorizontal" << endl;
						credit=credit+6;
					}
					 else	if(DuasVertical()){
								cout << "Ganhou o DuasVertical" << endl;
								credit=credit+6;
							}
							else	if(DuasDiagonais()){
										cout << "Ganhou o Duas Diagonais" << endl;
										credit=credit+6;
									}
									else	if(DHV()){
												cout << "Ganhou o uma horrizontal e uma Vertical e diagonal" << endl;
												credit=credit+6;
											}
											else	if(HV()){
														cout << "Ganhou o uma horrizontal e uma Vertical" << endl;
														credit=credit+4;
													}
													else	if(Diagonal()){
																cout << "Ganhou o Diagonal" << endl;
																credit=credit+3;
															}
															else	if(Horizontal()){
																		cout << "Ganhou o Horizontal" << endl;
																		credit=credit+3;
																	}
																	else	if(Vertical()){
																				cout << "Ganhou o Vertical" << endl;
																				credit=credit+3;
																			}
																			else
																				cout <<"Não ganhou !!!" <<endl;

		credit --;
		cout<<"Creditos: "<<credit<<endl;
		cout<<"Opção (y/n): ";cin>>op;
	}while((credit > 0) && (op == 'y'));
}
	if(op == 'n')
		cout<<"Ganhou "<<credit<<" Creditos."<<endl;

	if(credit==0)
		cout<<"Não tem mais creditos"<<endl;
}

O programa principal que faz o chamamento a todas as funções do Slot.cpp.

game.cpp:

#include <iostream>
#include <cstdlib>
#include <ctime>
#include "Slot.h"
using namespace std;
int main(){
	srand(time(0));
	Slot Machine01;
	Machine01.PlayTheGame();
}

Aqui fica a minha slot machine, um dia mais tarde talvez a volte a criar com um melhor design.

Módulo 08 – Conceitos Avançados de Programação

No inicio deste módulo começamos por realizar um trabalho de pares no qual consistia dizer o que é um Sistema Operativo, características de um Sistema Operativo, Sistemas operativos gráficos e “não gráficos”, elaborar uma lista de características dos sistemas operativos gráficos, identificando qual a vantagem associada, e o conceito de janela.

Aprendemos também a fazer a alocação dinâmica de memória em C++, onde aprendemos os comandos new e delete.

A declaração do apontador e a alocação da memória:

int *a = new int;

No fim libertar a memória que já não é utilizada:

delete a;

Módulo 7 – Manipulação de ficheiros

Durante este módulo aprendemos a fazer a manipulação da ficheiros binários e de texto, elaboramos neste módulo cinco fichas de trabalho onde nos ajudou a aprender mais sobre como manipular ficheiros. Aprendemos a abrir e a fechar ficheiros em vários modos de acesso, aprendemos a inserir e a fazer a leitura de texto no ficheiro de carácter-a-carácter, aprendemos também a a escrever e a ler ficheiros de texto formatado enas últimas aulas aprendemos a escrever e a ler ficheiros binários.

Abrir ficheiro:

fp =fopen("meutexto.txt","r");

Fechar ficheiro:

fclose(fp);

Escrever um carácter num ficheiro de texto:

fputc('a',ficheiro);

Lê um caracter de um ficheiro de texto:

caracter=fgetc(ficheiro);

Escrever dados num ficheiro formatado:

fprintf(fp, "%d %s %.1f", a, b, c);

Ler dados de um ficheiro formatado:

fscanf(fp, "%d %s %f", a, b, c);

Escrever para um ficheiro binário:

fwrite(x,sizeof(int), 5, fp);

Ler um ficheiro binário:

fread(x,sizeof(int), 5, fp);

Módulo 7 – Manipulação de ficheiros Binários

Nas ultimas aulas do modulo aprendemos a manipular ficheiros binários.

Aprendemos a escrever e a ler ficheiros binários.

Escrever no ficheiro binário:

fwrite(x,sizeof(int), 5, fp);

Ler ficheiro binário:

fread(x,sizeof(int), 5, fp);

Neste exemplo escreve num fichiero binário:

#include <stdio.h>
int main(int argc, char *argv[]){
	FILE *fp;
	int x[5], i;

	fp = fopen(argv[1], "wb");
	for(i = 0; i < 5; i++){
		printf("Inserir um numero na posicao %d do array: ",i);
		scanf("%d", &x[i]);
	}
	fwrite(x,sizeof(int), 5, fp);
	printf("Operacao efectuada\n");
	fclose(fp);
	return 0;
}

Outro exemplo, este lê um ficheiro binário:

#include <stdio.h>
int main(int argc, char *argv[]){
	FILE *fp;
	int x[5], i;

	fp = fopen(argv[1], "rb");
	if(fp == NULL){
		printf("O ficheiro nao e válido\n");
		return 1;
	}
	fread(x, sizeof(int), 5, fp);
	for(i = 0; i < 5; i++){
		printf("Array[%d] = %d\n",i, x[i]);
	}
	fclose(fp);
	return 0;
}

Modulo 7 – Escrever e ler ficheiros de texto formatado

Nas ultimas aulas aprendemos a escrever e a ler ficheiros de texto formatado.

Escrever dados formatados:

fprintf(fp, "%d %s %.1f", a, b, c);

Ler dados formatados:

fscanf(fp, "%d %s %f", a, b, c);

Este exemplo escreve dados no ficheiro num formato indicado:

#include <stdio.h>
int main(int argc, char *argv[]){

	FILE *fp;
	int a=11;
	char b[30]="texto";
	float c=12.50;

	fp = fopen(argv[1], "w");
    /*escreve dados no ficheiro num formato indicado*/
	fprintf(fp, "%d %s %.1f", a, b, c);
	fclose(fp);

	return 0;
}

Este exemplo lê dados do ficheiro no formato indicado:

#include <stdio.h>
int main(int argc, char *argv[]){

	FILE *fp;
	int a;
	char b[30];
	float c;

	if((fp = fopen(argv[1], "r"))!=NULL){
        /*lê dados do ficheiro no formato indicado*/
		fscanf(fp, "%d %s %f", &a, b, &c);
		printf("a = %d\n", a);
		printf("b = %s\n", b);
		printf("c = %.1f\n", c);
		fclose(fp);
	}
	else
		printf("O ficheiro especificado não existe!\n");
	return 0;
}

Módulo 7 – Manipulação de ficheiros de texto

este módulo de PSI estamos aprendemos a fazer manipulação de ficheiros de texto.

Durante as aulas fomos aprendendo varias maneiras de manipulação de ficheiros através de vários exercícios e fichas de trabalho. Ao longo das primeiras aulas aprendemos a abrir e fechar ficheiros em vários modos de acesso, depois inserimos e fizemos a leitura de texto no ficheiro de carácter-a-carácter

Exemplo:

#include<stdio.h>
int main(){
 FILE *fp;      //apontador para o ficheiro
 /*Abrir ficheiro*/
 fp =fopen("meutexto.txt","r");
 /*Fechar ficheiro*/
 fclose(fp);

 return 0;
}

Aprendemos também a escrever e a ler um carácter de um ficheiro.

Ler carácter:

caracter=fgetc(ficheiro);

Escrever carácter:

fputc('a',ficheiro);

Exemplo de um programa que lê os carácter de um ficheiro e escreve para outro ficheiro

#include<stdio.h>
int main(int argc, char *argv[]){
	FILE *fa, *fb;
	char caracter;

	fa=fopen(textoa,"r");
	fb=fopen(textob,"w");	

	/*Le caracater a caracter*/
	while((caracter=fgetc(fa))!=EOF){
		fputc(caracter,fb); //escreve os caracter no ficheiro

	fclose(fa);
	fclose(fb);

	return 0;
}

Outro exemplo, este programa verifica se um ficheiro existe:

#include <stdio.h>
int main(int argc, char *argv[]){
	FILE *fp;
	fp = fopen(argv[1],"r");
	if (fp==NULL)
		printf("ficheiro não existe\n");
	else{
		printf("Ficheiro já existe\n");
		fclose(fp);
	}
	return 0;
}

Nas proximas aulas iremos aprender a manipular ficheiros binários.

PSI

Este blog será o meu novo blog de programação, onde continuarei a colocar os meus vários trabalhos de programação, pensamentos e links de interesse sobre programação.

Jogo do galo – C++

Poucas aulas atrás o professor de programação lançou-nos o desafio de fazer o jogo do galo, eu achei um pouco complicado de fazer.

#include <iomanip>
#include <iostream>
#include <string>
using namespace std;
typedef struct{
	char pos[3][3];
}GALO;

void limpar_tabuleiro(GALO *g){
	int l,c;
	for(l=0;l<3;l++)
		for(c=0;c<3;c++)
			(*g).pos[l][c]=' ';
}
void mostrar(GALO g){
	cout<<"+---+---+---+"<<endl;
	cout<<"| "<<g.pos[0][0]<<" | "<<g.pos[0][1]<<" | "<<g.pos[0][2]<<" |"<<endl;
	cout<<"+---+---+---+"<<endl;
	cout<<"| "<<g.pos[1][0]<<" | "<<g.pos[1][1]<<" | "<<g.pos[1][2]<<" |"<<endl;
	cout<<"+---+---+---+"<<endl;
	cout<<"| "<<g.pos[2][0]<<" | "<<g.pos[2][1]<<" | "<<g.pos[2][2]<<" |"<<endl;
	cout<<"+---+---+---+"<<endl;

}

bool vazio(GALO p){
	bool vazio=true;
	int l,c;

	//verificar se o tabuleiro está vazio
	for(l=0;l<3;l++)
		for(c=0;c<3;c++)
			if(p.pos[l][c]!=' ')
				vazio=false;
	return vazio;
}
bool vitoriax(GALO p){
	//verificar vitória das x
	if(	(p.pos[0][0]=='x'&&p.pos[0][1]=='x'&&p.pos[0][2]=='x')||
		(p.pos[1][0]=='x'&&p.pos[1][1]=='x'&&p.pos[1][2]=='x')||
		(p.pos[2][0]=='x'&&p.pos[2][1]=='x'&&p.pos[2][2]=='x')||
		(p.pos[0][0]=='x'&&p.pos[1][0]=='x'&&p.pos[2][0]=='x')||
		(p.pos[1][0]=='x'&&p.pos[1][1]=='x'&&p.pos[1][2]=='x')||
		(p.pos[2][0]=='x'&&p.pos[2][1]=='x'&&p.pos[2][2]=='x')||
		(p.pos[0][0]=='x'&&p.pos[1][1]=='x'&&p.pos[2][2]=='x')||
		(p.pos[2][0]=='x'&&p.pos[1][1]=='x'&&p.pos[0][2]=='x'))
		return true;
	else	return false;

}
bool vitoriao(GALO p){
	//verificar vitória das o
	if(	(p.pos[0][0]=='o'&&p.pos[0][1]=='o'&&p.pos[0][2]=='o')||
		(p.pos[1][0]=='o'&&p.pos[1][1]=='o'&&p.pos[1][2]=='o')||
		(p.pos[2][0]=='o'&&p.pos[2][1]=='o'&&p.pos[2][2]=='o')||
		(p.pos[0][0]=='o'&&p.pos[1][0]=='o'&&p.pos[2][0]=='o')||
		(p.pos[1][0]=='o'&&p.pos[1][1]=='o'&&p.pos[1][2]=='o')||
		(p.pos[2][0]=='o'&&p.pos[2][1]=='o'&&p.pos[2][2]=='o')||
		(p.pos[0][0]=='o'&&p.pos[1][1]=='o'&&p.pos[2][2]=='o')||
		(p.pos[2][0]=='o'&&p.pos[1][1]=='o'&&p.pos[0][2]=='o'))
		return true;
	else	return false;
}

bool empateox(GALO p){
	//verificar empate
	int l,c;
	int ocupados=0;
	for(l=0;l<3;l++)
		for(c=0;c<3;c++)
			if(p.pos[l][c]!=' ')
				ocupados++;
	if(ocupados==9)
		return true;
	else	return false;
}

char vez(GALO g){
	int l,c;
	int o=0,x=0;
	for(l=0;l<3;l++)
		for(c=0;c<3;c++)
			switch(g.pos[l][c]){
				case 'x':x++;break;
				case 'o':o++;break;
			}
	if(x==o)
		return 'e';
	else	if(x>o)
				return 'o';
			else
				return 'x';
}
void jogar(GALO *p ,int posicao,char caracter){
	switch(posicao){
		case 1:(*p).pos[0][0]=caracter;break;
		case 2:(*p).pos[0][1]=caracter;break;
		case 3:(*p).pos[0][2]=caracter;break;
		case 4:(*p).pos[1][0]=caracter;break;
		case 5:(*p).pos[1][1]=caracter;break;
		case 6:(*p).pos[1][2]=caracter;break;
		case 7:(*p).pos[2][0]=caracter;break;
		case 8:(*p).pos[2][1]=caracter;break;
		case 9:(*p).pos[2][2]=caracter;break;
	}
}
int main(){
	GALO galo;
	char vez;
	int posicao;
	limpar_tabuleiro(&galo);

	vez='x';
	do{
		cout<<"Vai jogar o "<<vez<<"\n";
		mostrar(galo);
		cout<<"Indique a posição onde pretende jogar: ";cin>>posicao;
		jogar(&galo,posicao,vez);
		if(vez=='x')
			vez='o';
		else	vez='x';
	}while(!vitoriax(galo)&&!vitoriao(galo)&&!empateox(galo));
	mostrar(galo);
	if(empateox(galo))
		cout<<"O jogo terminou com um empate técnico!\n";
	else	if(vitoriax(galo))
			cout<<"Vitória do x\n";
		else	cout<<"Vitória do o\n";

	return 0;
}

As posições que o programa pede vão de 1 a 9 sendo 1, 2 ,3 da 1º linha, 4, 5, 6 2º linha, 7, 8, 9 da 3ºlinha.

O que são apontadores

Hoje na aula de programação aprendi o que são apontadores.
Eu acho que os apontadores são um pouco complicados ao inicio de compreender, mas depois de testarmos começamos a compreender melhor para que servem.

Aqui está um exemplo de um programa sem apontadores:

#include<iostream>
using namespace std;
int main(){
    int a=1,b=2;

	cout<<"A = "<<a<<endl;
	cout<<"B = "<<b<<endl;
	cout<<"A + B = "<<a+b<<endl;

	return 0;

}

E aqui está o mesmo programa só que com apontadores:

#include<iostream>
using namespace std;
int main(){
    int a=1,b=2;
    int *ptr_a=&a, *ptr_b=&b;

	cout<<"A = "<<*ptr_a<<endl;
	cout<<"B = "<<*ptr_b<<endl;
    cout<<"A + B = "<<*ptr_a+*ptr_b<<endl;

	return 0;
}

Com os apontadores, basicamente, podemos manipular os endereços da memória. Quando criamos uma variável, por exemplo “A”, é armazenado na memória um espaço que contem o valor de “A”. Quando voltamos a chamar a mesma variável, por exemplo “C=A+B”, é armazenado na memória outro espaço para a variável “A”. Com os apontadores podemos usar sempre o mesmo local de armazenamento da variável “A” sem mexer nas variáveis.

Os seguintes termos significam:

• & significa “endereço de”.
• * significa “aponta para”, ou se quisermos, “conteúdo do endereço apontado por”.

“HELLO WORLD”

Aqui temos um pequeno video do famoso programa “HELLO WORLD”.

Este é um bom exemplo de um programa para quem ainda esta a começar a programar.