Murilo :P

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.