Static Template Matrix?

De fato eu nunca vi esse nome em outro lugar, mas foi o nome que eu pensei que se aproxima mais da implementação que veremos nesse post.

Trata-se template de uma matriz (matrix) de duas dimensões de tamanho constante (static). Uma das diferenças dessa matriz é que ao invés de se usar o convencional operator[] para acessar os elementos, nessa abordagem iremos utilizar o operator().

Motivações

Na realidade, não tem muito mais utilidades práticas do que matrizes normais. Pode ser que pode servir em algo para você. Então minha motivação é puramente de aprendizagem, principalmente da linguagem.

matrix.h

#ifndef _CLASS_MATRIX_H__
#define _CLASS_MATRIX_H__

/**
 * matrix.h
 * Defines a template type 'matrix' wich is a constant-sized 2-dimensioned
 * 	matrix and generic typed elements.
 *
 * author: Murilo Adriano Vasconcelos
 * website: http://murilo.wordpress.com
 */

template
class matrix
{
    //data matrix
    T data[R][C];

    public:
    //type of the current matrix
    typedef matrix matrix_t;

    //quantity of rows
    const unsigned rows;
    //quantity of columns
    const unsigned columns;

    //default ctor
    matrix(): rows(R), columns(C) {};

    /*ctor wich initializes the matrix filled
      with 'value' elements */
    matrix(const T& value);

    //copy ctor: copies the matrix 'tocopy'
    matrix(const matrix_t& tocopy);

    /*gets and/or set the value of the element
      in the row 'i', column 'j' */
    T& operator()(unsigned i, unsigned j);

    /*gets the value of the element in the
      row 'i', column 'j' */
    const T& operator()(unsigned i, unsigned j) const;

    //copy operator
    matrix_t& operator=(const matrix_t& tocopy);
};

/* class functions definition */

    template
matrix::matrix(const matrix& tocopy): rows(R), columns(C)
{
    for (int i = 0; i < R; i++)
        for (int j = 0; j < C; j++)
            data[i][j] = tocopy(i, j);
}

    template
matrix::matrix(const T& value): rows(R), columns(C)
{
    for (int i = 0; i < R; i++)
        for (int j = 0; j < C; j++)
            data[i][j] = value;
}

template
    matrix&
matrix::operator=(const matrix& tocopy)
{
    for (int i = 0; i < R; i++)
        for (int j = 0; j < C; j++)
            data[i][j] = tocopy(i, j);

    return *this;
}

    template
T& matrix::operator()(unsigned i, unsigned j)
{
    return data[i][j];
}

template
const T& matrix::operator()(unsigned i, unsigned j) const
{
    return data[i][j];
}

#endif

main.cpp

#include "matrix.h" //our matrix
#include  //cout'ing
#include    //for strings

int main()
{
        //declares a 3x3 matrix filled with "nil"
        matrix mat("nil");

        //modifies the value in the position (1, 1) to C++
        mat(1, 1) = "C++";

        //we can use the const atribbutes rows and columns
        //to check our limits
        for (int i = 0; i < mat.rows; i++) {
                for (int j = 0; j < mat.columns; j++) {
                        //getting, setting the value of matrix elements
                        //is the same way
                        std::cout << mat(i, j) << ' ';
                }

                std::cout << '\n';
        }

        std::cout << '\n';

        matrix ones(1), identity;
        //copy
        identity = ones;

        //so silly
        for (int i = 0; i < identity.rows; i++) {
                for (int j = i; j < identity.columns; j++) {
                        if (i != j) {
                                identity(i, j) = identity(j, i) = 0;
                        }
                }
        }

        for (int i = 0; i < identity.rows; i++) {
                for (int j = 0; j < identity.columns; j++) {
                        std::cout << identity(i, j) << ' ';
                }

                std::cout << '\n';
        }

        return 0;
}

Como vocês puderam notar, a forma de acesso e modificação (get, set) dos elementos da matriz é da mesma forma. Outra coisa que podemos notar é que passamos o tipo e a quantidade de linhas e colunas direto no template. A quantidade de linha e colunas passada deve ser uma constante.

Bom, até mais.

obs.: Eu odeio profundamente o source highlight bugado do WordPress que converte todos os meus < e > e etc. para &lt; &gt;. Por isso os fontes acima não estão com hl.

Agora sim, até mais.

Considerações

Bem, eu ainda não tinha escrito nada sobre a fase regional da XIV Maratona de Programação que ocorreu dia 19 de setembro por falta de tempo e porque não havia recebido as fotos do evento.

O primeiro ponto que quero destacar é a estrutura da regional aqui de Goiânia. Não deixou nada a desejar! Ambiente ótimo, infra-estrutura boa, máquinas, espaço, equipamento, organização. Tenho que parabenizar os professores que organizaram o evento, principalmente os professores Humberto Longo e Cláudio Nogueira do INF-UFG.

Esse ano (2º da regional de Goiânia) participaram 11 equipes de 5 instituições: ALFA (1), IFG-Morrinhos (2), UEG (2), PUC-GO (3) e INF-UFG (3).

Local da competição

Antes…

Na chegada das equipes, pude reencontrar vários amigos, principalmente da PUC-GO e aí os assuntos ficaram em dia (conversamos sobre computação, lógico). O clima estava típico de uma decisão mesmo: em um segunto estávamos conversando e rindo, no outro estávamos tensos e pensativos.

Galera no corredor

Antes de começar o warm-up, tivemos uma “mini-palestra” sobre as regras da maratona e de como usar o sistema BOCA e entregas de credenciais, logins/senhas e das plaquinhas que identificam as equipes.

Pré-warm-up

O warm-up foi tranquilo, só pra testes mesmo. Parece que houve um problema no julgamento do problema “Bolhas e Baldes” que posteriormente foi solucionado.

Fim de warm-up, fomos almoçar. Como o campus é uma cidade a parte, quase todo mundo almoçou no mesmo lugar, tendo calculado o menor caminho ou não .

Começa a maratona e aí vira tensão…

Começa a competição e com 6 minutos, minha equipe (UFG – Monkeys) recebe o primeiro AC da competição: problema B – “Alarme”, Carlitos na implementação. Não sei dizer mas acho que esse foi um dos balões mais rápidos do Brasil.

Não demorou e nossa principal rival, a PUC-GO – Mother Focas, e a UFG – Sobrevientes do RU conseguiram também seus balões amarelos.

Os Focas: Jackie, Divinera e Marciano

Até os 3 primeiros balões nós lideramos com uma certa vantagem no tempo. O problema foi quando os Focas conseguiram o quarto balão e nós não. Aí bateu aquele “caramba, agora fodeo!”. Aí focamos no problema (que por sinal era muito simples) e mandamos… Recebemos um NO bem grande e aí bateu o desespero. Consegui achar a lógica, conferi com meus colegas a corretude e, finalmente YES! Na hora olhamos para o Score que estava num telão na nossa frente e vimos que tinhamos passado os Focas (na verdade olhei o score mesmo assim deu um branco não saquei nada e tive que perguntar a nossa posição pra minha equipe [sic]).

Alguns balões

Ficamos focados no problema G – “Registrador” e perdemos tempo, muito tempo [sic²]. Quando vimos, tinham 6 equipes com 4 balões, aí de novo bateu o pensamento “fodeo”…

No freeze, conseguimos formular um algoritmo pro E – “Dragster” mas aí já era tarde… Estávamos exaustos e não conseguimos codificá-lo. Enquanto isso, eu estava tentando ter a sacada do F – “Torres de Celular” (pô, tava na cara e eu não enxerguei). E o freeze-time foi isso: Diego e Carlos no Dragster (esse dava hein) e eu tentando algo no Torres de Celular.

Nosso quarto balão. Monkeys: Murilo, Carlos e Diego

A cada vez que nós víamos alguem teclando algo no freeze, dava um frio na barriga. Tentamos fazer uns “cortes” no registrador e mandamos várias outras vezes.

Score Final

Por um problema na rede (ou de juízes engraçadinhos), o score final demorou uma eternidade após a competição a ser apresentado a nós (aproximadamente 4min e 30seg). Anunciado o vencedor, só alegria.

Comemoração

Mais algumas fotos

PUC-GO Bit a bit: Douttor, Mauricinho e Loos

UFG - Sons of a Bit: Nemo, Will e PC

UFG - Sobreviventes do RU: Everton, Will e Lup

A única competidora, o japa e o barba

Os melança

Premiação

É… teve premiação com direito a reitor e tudo mais. Auditório cheio e prêmios para os vencedores

As três primeiras equipes ganharam camisetas geeks, medalhas e trófeus além de um livro (alguns dos prêmios concedidos pela SistemasAbertos).

Nós da Monkeys ganhamos uma camiseta personalizada da Maratona de Programação, como essa abaixo do Longo branca.

3º Lugar - UFG - Sons of a Bit e o coach Humberto Longo

2º Lugar - PUC-GO - MotherFocas, pró-reitora de graduação e o coach Alexandre

1º Lugar - UFG - Monkeys, coach: Humberto Longo e o reitor

MONKEYS

E agora…

Final Nacional em Campinas

Rumo a Tóquio, ops, Harbin na China!!

O scoreboard, clarifications e etc podem ser visualizados aqui.

Pessoal não ando postando algo aqui porque estou muito sem tempo mesmo. Meu time (UFG – Monkeys) passou para a final nacional da maratona de programação, as matérias do período estão bastante árduas e comecei a estagiar na universidade por isso a falta de tempo.

Encerro esse post com uma imagem que achei na grande rede sobre trabalho em equipe:

Esse é o caminho

Para quem ainda não conhece, Boost é um conjunto de bibliotecas C++ multiplataforma que trabalha bem com a STL e é muito bem aceita na comunidade. Já existem dez bibliotecas Boost incluídas no C++ TR1 e que estarão no C++0x além de muitas outras que estarão no C++0x e que atualmente não estão no TR1.

Para instalar o boost siga esse Getting Started.

Fazer threads com boost::thread é muito simples. Basta criar uma função ou um functor e passar pro construtor da classe boost::thread:

class functor
{
public: void operator()() {};
};

functor::operator()()
{
	/* content */
}

void function()
{
	/* content */
}

functor obj;
boost::thread tObj(obj); //passa uma cópia de obj
boost::thread tObjRef(boost::ref(obj)); //passa uma referência para obj
boost::thread tFunc(&funcao);

//inicia a execução das threads
tObj.join();
tObjRef.join();
tFunc.join();

//ou pode-se criar grupos de threads

boost::thread_group my_threads;
my_threads.create_thread(obj);
my_threads.create_thread(boost::ref(obj));
my_threads.create_thread(&function);

my_threads.join_all(); //inicia a execução de todas as threads desse grupo

Para ilustrar como funciona, fiz dois programinhas simples:

cin.cpp

#include <iostream>
#include <boost/thread/thread.hpp>
#include <boost/thread/xtime.hpp>

//determina se o usuário já entrou com o número
bool flag = false;

struct in
{
	int n;

	in() : n(0) {};

	void operator()()
	{
		//try to read the number
		while (!(std::cin >> n)) {
			std::cin.clear();
			std::cin.ignore(10000, '\n');

			std::cout << "Enter a valid number" << std::endl;
		}

		flag = true;
	}

};

void my_alarm()
{
	while (!flag) {
		//shows the message
		std::cout << "Enter a number" << std::endl;

		boost::xtime time;
		boost::xtime_get(&time, boost::TIME_UTC); //current time

		time.sec += 5; //adds 5 secs to time
		//sleep 5 secs
		boost::thread::sleep(time);
	}

	//exiting function
	std::cout << "Alarm finished" << std::endl;
}

int main()
{
	in test;

	//create the two threads
	boost::thread tin(boost::ref(test));
	boost::thread tal(&my_alarm);

	//start
	tin.join();
	tal.join();

	//show the user's number
	std::cout << "Ok " << test.n << std::endl;

	return 0;
}

Esse programa é composto por duas threads (fora o fluxo principal) uma que é responsável por fazer a leitura de um número e a outra que fica a cada 5 segundos mostrando uma mensagem “Enter a number” enquanto o usuário não digitar um número válido. Quando o usuário digita um número válido, a flag é setada e os loops das duas threads são finalizados. Finalmente quando as duas threads são finalizadas, o fluxo normal de main() é reestabelecido e é mostrado o número digitado pelo usuário.

Lembrando que para usar boost::thread é necessário “linkar” a biblioteca ao programa. No caso do Linux é necessário linkar também a biblietca pthread em Windows “linkar” a win32api. No meu caso preferi usar linkagem estática.

O outro exempo que fiz é um programinha que faz a multiplicação de duas matrizes e “simultaneamente” (depende de processador e SO) mostra uma barra de progresso com o progresso da operação.

multiplica.cpp

#include <iostream>
#include <boost/thread/thread.hpp>
#include <boost/thread/xtime.hpp>

const int MAX = 1000;

int A[MAX][MAX];
int B[MAX][MAX];
int C[MAX][MAX];

int porcentagem = 0;

void multiplica()
{
	int soma;	

	for (int i = 0; i < MAX; i++) {
		for (int j = 0; j < MAX; j++) {
			soma = 0;
			for (int k = 0; k < MAX; k++) {
				soma += A[i][k] * B[k][j];
			}

			C[i][j] = soma;
		}
		if (i % 10 == 0) porcentagem++;
	}
}

void barra_de_progresso()
{
	int atual = 0;
	while (porcentagem != 100) {
		if (atual != porcentagem) {
			if (porcentagem % 10 == 0) {
				std::cout << "\b\b" << porcentagem << '%';
			}
			else std::cout << '=' << std::flush;

			atual++;
		}
	}
}

int main()
{
	boost::thread tMultiplica(&multiplica);
	boost::thread tProgresso(&barra_de_progresso);

	boost::xtime inicio, fim;
	boost::xtime_get(&inicio, boost::TIME_UTC);

	std::cout << "Iniciando a multiplicação de matrizes" << std::endl;

	tMultiplica.join();
	tProgresso.join();

	boost::xtime_get(&fim, boost::TIME_UTC);

	std::cout << "\n\nProcesso terminado em " <<
		(fim.sec - inicio.sec) << " segundos" << std::endl;

	return 0;
}

Saída:

Claro que o que menos nos importa nesse momento é o valor das matrizes e a multiplicação em si, por isso nem me dei ao trabalho de inicializar as matrizes nem de fazer nada com a matriz resultante.

Acredito que para uma introdução está bom e deu pra mostrar como é fazer programas com boost::thread com esses simples exemplos. Mais exemplos você pode encontrar na pasta libs do boost.

Links:

• Boost Thread
• TR1 paper

Olá, hoje eu vou dar um tempo na série “Coisas simples de se fazer em C++ que alguns ainda complicam” e irei falar sobre uma experiência minha tentando alguma maneira de programar em C orientado a objetos.

Sei que muitos vão pensar “pra quê isso?” ou dizer que é péssimo fazer isso ou coisa parecida, mas o intuito desse post é outro: é mostrar o que é possível fazer ou até mesmo enxergar alguma utilidade nisso. Nesse blog, procuro colocar coisas diferentes, curiosidades sobre programação e linguagens, porque acho que conteúdo “normal” já existem em muitos lugares na grande rede.

O que me instigou a fazer isso foi um post no CODARE “C: Escondendo o conteúdo de structs com tipos incompletos” de autoria do Thiago Santos, no qual ele cita sobre usar com orientação a objetos em C.

Li, achei interessante e quis, vamos dizer assim, dar um cara mais parecida de orientação a objetos ao que ele fez.

O primeiro passo foi pensar em como funcionam os famosos objetos.
Uma classe em uma linguagem orientada a objetos geralmente tem 2 tipos de elementos:

• Elementos de classe: elementos (funções e variáveis estáticas) que só são criados uma vez, todos os objetos da classe tem acesso ao mesmo elemento.
• Elementos de instância (ou objeto): elementos (atributos) que são criadas para cada objeto instanciado.

Ou seja:

class Animal
{
        int age;
        std::string specie;
        static int count;
public:
        int birthday();
};

No exemplo acima, age e specie são elementos de instância, ou seja, cada objeto têm o seus próprios. Já count e birthday() são de classe, pois todos os objetos dessa classe utilizarão o mesmo. O que ocorre no caso de funções é que na chamada da função, um ponteiro do objeto chamador é passado para a função. Isso faz com que não precise a cada instância de objeto criar uma nova função já que elas fazem a mesma coisa.

Algo como:

Animal animal, animal2;

//lembrando que é APENAS uma ilustração do que acontece
//não é assim que é realmente implementado mas é a mesma idéia
//uma função só para todos os objetos de uma classe

animal.birthday(); //vtable::animal::birthday(&animal);
animal2.birthday(); //vtable::animal::birthday(&animal2);

A função birthday() é a mesma para as duas chamadas, o que muda é o ponteiro para os dados de cada objeto.

A minha implementação seguiu a idéia do Thiago Santos: uma classe person que tem os atributos name e age funções para instanciar, imprimir o nome e idade e deletar o objeto.

Vamos então dar uma olhada no nosso headerperson.h:

#ifndef PERSON_H__
#define PERSON_H__

//Incomplete type declaration
typedef struct person_private person_private;

typedef struct person {
	//"private" data.
	person_private* data;

	//"class" functions
	void (*free)();
	void (*print)();
} person;

//instatiate a new person
person* new_person(const char*, int);

//pointer to the actual person in the context
person* __actual_person;

//sets the actual person
person* _(person* obj);

#endif

Nosso header contém a declaração incompleta de person_private leia aqui para saber o porquê, a definição da nossa “classe” person, as declarações das funções new_person() e _() e um ponteiro __actual_person.

Nossa “classe” person contém um ponteiro data para os dados que não poderão ser acessíveis através do objeto (name, age) além de ponteiros para funções (que serão nossos “métodos”).

A função new_person simplesmente instancia um objeto do tipo person.

O ponteiro __actual_person irá funcionar como o ponteiro passado para as funções de classe. Através do ponteiro saberemos qual objeto chamou a função.

A função _() seta o ponteiro __actual_person para que as funções sejam corretamente chamadas. Nota: não é thread safe. (hehehe)

Vamos ao nosso person.c:

#include "person.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

//private data... visible only by the functions below
struct person_private
{
	char* name;
	int age;
};

//a "manual destructor"
void free_person()
{
	free(__actual_person->data->name);
	free(__actual_person->data);
	free(__actual_person);

        puts("Person sucessfuly freed!\nBye");
}

//prints
void print_person()
{
	printf("%s -: %d\n", __actual_person->data->name,
		 __actual_person->data->age);
}

person* new_person(const char* name, int age)
{

	//Allocate the object
	person* new = (person*)malloc(sizeof(person));
	new->data = (person_private*)malloc(sizeof(person_private));

	//Initialize the data
	new->data->name = (char*)malloc(strlen(name) * sizeof(char) + 1);
	strcpy(new->data->name, name);

	new->data->age = age;

	//Set the functions pointers
	new->print = print_person;
	new->free = free_person;

	return new;
}

//must call the objects with this function
person* _(person* obj)
{
	__actual_person = obj;
	return obj;
}

O que temos aí é a função _() que seta o objeto atual (__actual_person) para que possa ser utilizado a função com o objeto certo, a função new_person que funciona como nosso construtor, as outras duas funções que são os “métodos da classe” print e free e a definição da estrutura person_private que contém os atributos da classe.
Os comentários ajudam no resto .

Vamos então ver o main.c que é o nosso teste:

#include <stdio.h>
#include "person.h"

int main()
{
	//Instantiates 2 persons
	person* person1 = new_person("Murilo", 21);
	person* person2 = new_person("Rovane", 47);

	//print
	_(person1)->print();
	_(person2)->print();

	//free
	_(person1)->free();
	_(person2)->free();
}

Eis o resultado:

Nota: deve-se usar sempre a função _() para utilizar o objeto.

Fiquei pensando se tem como fazer uma espécie de gerador de classes nesse formato no próprio C (com macros por exemplo). Vou procurar saber se existe algo a respeito, são 04h40min da mardugada não estou mais com boas idéias.

Qualquer sugestão, bug, idéia, reclamação, estamos aí!

Bom, essa é a segunda parte da série e vamos falar sobre uma maneira simples de aplicar uma função à todos os elementos de um contêiner STL (vector, list, deque, stack, etc) ou à todos os elementos de uma std::string.

Para isso usaremos a função std::transform().

No nosso primeiro exemplo, usaremos transform() com uma função que retorna o quadrado de um número.

#include <iostream> //cout
#include <algorithm> //transform()
#include <vector>

using namespace std;

int quadrado(int num)
{
        return num * num;
}

int main()
{
        vector<int> vetor;
        for (int i = 0; i < 10; i++) vetor.push_back(i);

        transform(vetor.begin(), //iterator pro incio do range desejado
                vetor.end(), //iterator para o fim do range
                vetor.begin(), //iterator para conteiner o destino
                quadrado //função a ser aplicada
        );

        //imprime os valores.
        vector<int>::iterator it;
        for (it = vetor.begin(); it != vetor.end(); it++) {
                cout << *it << ' ';
        }
        cout << endl;
        return 0;
}

Saida:

0 1 4 9 16 25 36 49 64 81

No segundo exemplo, mostramos como converter uma std::string para minúsculo com transform():

#include <iostream> //cout
#include <algorithm> //transform()
#include <string>
#include <cctype> //tolower, toupper

using namespace std;

int main()
{
        string url = "HTTP://MURILO.WORDPRESS.COM";
        transform(url.begin(), url.end(), //origem
                url.begin(), //destino
                ::tolower); //função tolower da <cctype> (necessário ::)

        cout << url << endl;
        return 0;
}

Saída

http://murilo.wordpress.com

transform() também aceita funções com dois parâmetros, para que possamos aplicar uma função aos valores de dois contêineres e armazenarmos em um:

#include <iostream> //cout
#include <algorithm> //transform()
#include <complex>
#include <vector>

using namespace std;

complex<int> func(int real, int imag)
{
        return complex<int>(real, imag);
}

int main()
{
        vector<int> real; //parte real
        vector<int> imag; //parte imaginaria

        real.push_back(1);
        real.push_back(3);
        real.push_back(152);

        imag.push_back(5);
        imag.push_back(8);
        imag.push_back(12);

        vector< complex<int> > complexo(3); //reserva 3 posicoes

        transform(real.begin(), real.end(), //origem
                imag.begin(), //origem do segund
                complexo.begin(), //destino
                func //função
        ); 

        vector< complex<int> >::iterator it;
        for (it = complexo.begin(); it != complexo.end(); it++) {
                cout << *it << endl;
        }

        return 0;
}

Saída:

(1,5)
(3,8)
(152,12)


Até a próxima.
Ver a primeira parte da série.

Bom, vou fazer uma série de posts dizendo sobre coisas simples de se fazer em C++ que muitos ainda complicam. A idéia surgiu do post de um colega.

O primeiro post dessa série é sobre como imprimir facilmente todos os valores de um contêiner STL.

Iremos usar para isso, ostream_iterators que fornecem iterators para escrita em streams de saída. ostream_iterator está declarado em .

Vamos ao nosso exemplo:

#include <iostream> //para cout
#include <iterator> //para ostream_iterator
#include <vector>

using namespace std;

int main()
{
        vector<int> v(5);
        v[0] = 1;
        v[1] = 1;
        v[2] = 2;
        v[3] = 3;
        v[4] = 5;

        //copia todo o vetor [begin() -> end()) pro cout com um  ", " de delimitador
        copy(v.begin(), v.end(), ostream_iterator<int>(cout, ", "));
}

Resultado:


1, 1, 2, 3, 5,


A seguir um exemplo mais funcional, um gerador de arquivos CSV. Ao invés de usarmos o ostream_iterator(cout, ","), utilizaremos ostream_iterator(arquivo, ";") que diz que que queremos passar strings para serem escritas em um arquivo de texto com o delimitador ";":

#include <fstream> //para ofstream
#include <iostream> //para cerr
#include <iterator> //para ostream_iterator
#include <vector>
#include <string>

#define DELIMITADOR ";"

using namespace std;

int main()
{
        typedef vector< vector<string> > vvs;
        vvs csv(3); 

        //preenchendo
        vector<string> v;
        v[0] = "'Murilo Adriano'";
        v[1] = "'muriloufg(at)gmail(dot)com'";
        v[2] = "8888-8888";
        v[3] = "'murilo.wordpress.com'";
        csv[0] = v;

        vector<string> v2(4);
        v2[0] = "'Outra Pessoa'";
        v2[1] = "'outoemail(at)outrohost(dot)com'";
        v2[2] = "9999-9999";
        v2[3] = "'website.com'";
        csv[1] = v2;

        vector<string> v3(4);
        v3[0] = "'Foo Bar'";
        v3[1] = "'foo(at)bar(dot)com'";
        v3[2] = "0000-0000";
        v3[3] = "'foobar.com'";
        csv[2] = v3;       

        //tenta abrir o arquivo
        ofstream arquivo("planilha.csv");
        if (arquivo.is_open()) {
                vvs::iterator it;
                for (it = csv.begin(); it != csv.end(); it++) {
                        //escreve os elementos de cada item do vetor no arquivo
                        copy((*it).begin(), (*it).end(),
                                ostream_iterator<string>(arquivo, DELIMITADOR));

                        //quebra uma linha
                        arquivo << '\n';
                }

                arquivo.close(); // fecha o arquivo
        }
        else {
                //se não foi possível abrir o arquivo
                cerr << "Falha ao abrir o arquivo\n" << endl;
        }
}

Após rodar o programa, abra o arquivo gerado no seu software de planilha eletrônica preferido e veja o resultado:

Arquivo gerado pelo programa acima aberto no OpenOffice

É isso aí pessoal, nos próximos posts exploraremos mais o C++ e STL.
Até a próxima.

Mais uma trick com enums.

A sobrecarga de operadores podem facilitar o manuseio de enums. Abaixo está um exemplo de como pode ser útil a sobrecarga do operator++.

#include <iostream>

using std::cout;
using std::endl;

enum Semana
{
        DOM,
        SEG,
        TER,
        QUA,
        QUI,
        SEX,
        SAB
};

Semana& operator++(Semana& dia) //pré-incremento
{
        return dia = static_cast<Semana>((dia + 1) % 7);
}

Semana& operator++(Semana& dia, int) //pós-incremento
{
        return dia = static_cast<Semana>((dia + 1) % 7);
}

int main()
{
        Semana dia = SEX;
        cout << dia << endl; // SEX (5)
        cout << ++dia << endl; // SAB (6)
        cout << ++dia << endl; // DOM (0)
        dia++; // SEG (1)
        cout << dia << endl;
}

Quando chegamos no último dia da semana (SAB) e chamamos o operator++, obtemos o primeiro dia da semana graças ao operador módulo (%).

Referência.

Dessa vez não vou falar muito mas sim exemplifiar um dos features (hehehe) do C++ que são as diferentes maneiras de “construir” um objeto. O código está todo em um arquivo para facilidar a visualização aqui no blog.

Eis o código:

#include <iostream>

using std::cout;

class Teste
{
        char tipo;
        int valorInt;
        char valorChar;
        double valorDouble;

public:
        Teste(const Teste& t)
        {
                tipo = t.getTipo();
                valorInt = t.getValorInt();
                valorChar = t.getValorChar();
                valorDouble = t.getValorDouble();
        }

        Teste(char v)
        {
                tipo = 'c';
                valorInt = 0;
                valorChar = v;
                valorDouble = 0;
        }

        Teste(int v)
        {
                tipo = 'i';
                valorInt = v;
                valorChar = 0;
                valorDouble = 0;
        }

        Teste(double v)
        {
                tipo = 'd';
                valorInt = 0;
                valorChar = 0;
                valorDouble = v;
        }

        char getValorChar() const { return valorChar; };
        int getValorInt() const { return valorInt; };
        double getValorDouble() const { return valorDouble; };
        char getTipo() const { return tipo; };

        void imprimeValor() const
        {
                if (tipo == 'c') cout << valorChar;
                else if (tipo == 'd') cout << valorDouble;
                else cout << valorInt;

                cout << '\n';
        };

        ~Teste() {};

};

int main()
{
        Teste a = 1;
        Teste b = 'm';
        Teste c = 3.1417;
        Teste d = (Teste)2;
        Teste e = a;
        Teste f(100);
        Teste g = static_cast<Teste>('a');

        a.imprimeValor();
        b.imprimeValor();
        c.imprimeValor();
        d.imprimeValor();
        e.imprimeValor();
        f.imprimeValor();
        g.imprimeValor();

}

E a saída correspondente:

1
m
3.1417
2
1
100
a


Internamente todas as formas de construir o objeto fazem a mesma coisa: procuram um construtor que espere aquele tipo de parâmetro e cria um objeto (no caso Teste).

Claro que isso pode ser modificado se sobrecarregarmos o operator=, operator() (unário) ou usar a keyword explicit na declaração dos construtores.

O que são os enums (C e C++)

Um enum (enumeração) é um tipo definido pelo usuário (programador) que consiste em constantes do tipo int nomeadas.

Um jeito tradicional de se declarar constantes em C e C++ é o seguinte:

#define BRASIL 0
#define ITALIA 1
#define PORTUGAL 2
#define ALEMANHA 3

E eis a maneira de fazer o mesmo utilizando enums:

enum
{
        BRASIL,
        ITALIA,
        PORTUGAL,
        ALEMANHA
};

Pode-se, alternativamente, criar um tipo para seu enum:

enum Paises
{
        BRASIL,
        ITALIA,
        PORTUGAL,
        ALEMANHA
};

E declarar uma variável desse tipo com:

Paises pais; //C++ apenas
enum Paises pais; //C e C++

Num enum igual a esses acima, a primeira constante recebe o valor 0 e as subsequentes recebem o valor da constante anterior mais 1. Ou seja, BRASIL é 0, ITALIA é 1, PORTUGAL é 2 e ALEMANHA é 3.
Podemos também atribuir valores manualmente às constantes como em:

enum Paises
{
        BRASIL = 2,
        ITALIA,  //ITALIA é igual a 3 (2 + 1)
        PORTUGAL = 1,
        ALEMANHA  //ALEMANHA é igual a 2 (1 + 1)
};

Como podemos perceber no exemplo anterior, a mesma regra se aplica para os enums com valores manuais, o que não tiver um valor explicitamente inserido receberá o valor do anterior somado em 1. Percebemos também que podem haver constantes com o mesmo valor (BRASIL == ALEMANHA == 2).

Conversão

A conversão de uma constante de um enum para um inteiro por exemplo é feita automaticamente. Já o contrário não deve ser permitido pelo compilador.

enum Paises
{
        BRASIL,
        ARGENTINA,
        VENEZUELA
};

...

int inteiro = VENEZUELA + 2; //4
Paises pais = 3; //ERRO

Uma melhor maneira de usar enums em C++

Veja o exemplo:

enum Paises
{
        BRASIL,
        ITALIA,
        ALEMANHA
};

enum Uvas
{
        RUBI,
        ITALIA,
        UMOUTROTIPODEUVA
};

Isso irá ocasionar um erro porque ITALIA já foi definido. A saida do meu compilador (g++ 4.3.2) foi a seguinte:

murilo@blacksheep:~/$ g++ enums.cpp
enums.cpp:14: error: conflicting declaration ‘ITALIA’
enums.cpp:8: error: ‘ITALIA’ has a previous declaration as ‘Paises ITALIA’


Mas e agora?? Eu quero ter dois enums diferentes que representam coisas diferentes mas que podem ter a mesma constante. Como?

A resposta é namespaces!
Em C++ podemos declarar nossos enums dentro de namespaces e assim termos as constantes em espaços de nomes diferentes. Nada de conflito agora hein g++!!!

namespace Paises
{
        enum
        {
                BRASIL,
                ITALIA,
                ALEMANHA
        };
}

namespace Uvas
{
        enum
        {
                RUBI,
                ITALIA,
                UMOUTROTIPODEUVA
        };
}

//*...*//
//Modo de uso:

std::cout << Uvas::ITALIA;
std::cout << Paises::ITALIA;

É isso aí galera, até a próxima.