Windows 7.0 – Revolucionário?!?!
Publicado por: John em: 10 10UTC Janeiro 10UTC 2009
Windows 7
CUDA: Módelo de Programação Paralela
Publicado por: John em: 30 30UTC Dezembro 30UTC 2008
O advento das CPUs multicore e das GPUs manycores significa que o caminho para desenvolvimento de novos processadores são sistemas paralelos. Além disso o paralelismo obtido com estes chips continuam com a evolução prevista pela lei de Moore [6]. O desafio agora é desenvolver softwares que consigam utilizar de forma eficiente o número de cores disponíveis no sistema e que a performance destes acompanhe de forma transparente o aumento do número de nucleos disponíveis. Aplicações com estas caracteristicas já existem na área de jogos, as quais utilizam os recursos disponíveis para manipular imagens de alta resolução e produzir cenas o mais realistas possíveis em frações de segundos.
CUDA é um modelo de programação paralela e um ambiente de software projetado para superar estes desafio enquanto requer uma baixa curva de aprendizado para programadores familiares com linguagens tradicionais como a linguagem C.
CUDA é composta de três abstrações principais, a saber: uma hierarquia de grupo de threads, memorias compartilhadas, sincronização via barreiras – que são expostos para o programador atraves de um conjunto minimo de extenções para a linguagem C.
Estas abstrações possibilitam o paralelismo de dados e threads. Elas levam o programador a particionar o problema em subproblemas que podem ser solucionados independentemente em paralelo e então combinar estas partes para que possam ser trabalhadas cooperativamente. Tão decomposição preserva a expressividade da linguagem e permite que as threads cooperem quando estiverem trabalhando nos subproblemas, e ao mesmo tempo permite uma evolução de performance de forma transparente já que cada subproblema pode ser agendado para ser executado em qualquer um dos núcleos disponíveis: Um programa em CUDA pode portanto executar em qualquer número de núcleos, apenas o sistema de runtime precisa saber quantos núcleos estão disponívei.
GPU: Processador manycore altamente paralelo
Movido pelo insaciavel demanda de mercado por aplicações de tempo real, graficos 3D de alta definição a GPU evoluiu para um processador manycore altamente paralelo com um gigantesco poder de computação e uma grande largura de barramento de memória, como ilustrado pela figura 1.
Figura 1
A razão por trás da grande diferença de poder de computaçaõ entre a CPU e a GPU é que a GPU é especializada para tarefas de computação intensiva e altamente paralela – exatamente o que renderização gráfica trabalha – e portanto foi projetada de forma que mais transistores são dedicados para processamento ao inves utiliza-los para cache e/ou controle de fluxo, veja a figura 2 para uma representação gráfica.
Figura 2
Mais especificamente, a GPU foi especialmente projetada para resolver problemas que podem ser expressos em termos de computações com diversos dados em paralelo – o mesmo programa é executado para cada elemento de dado em paralelo – e com alta necessidade de aritimetica. Devido ao mesmo programa ser executado para cada porção de dados, existe pouca necessidade de uma unidade de controle de fluxo sofisticada; e porquê ele é exeuctada em diversos dados em paralelos e tem alta requisição para calculos, a latencia de acesso a memória pode ser ocultada com calculos ao inves de caches gigantes.
Processamento de dados em paralelo mapeia a mesma porção de dados para diversas threads ao mesmo tempo. Muitas aplicações que processam grandes quantidades de dados podem utilizar um modelo de programação paralelo para acelerar suas as computações realizadas. Na renderização 3D grandes conjuntos de pixels e vertices são mapeados para threads executando em paralelos. Aplicações de processamento de imagem e video tais como codificação e decoficação de video, redimencionamento de imagem, visão computacional e reconhecimento de padrões, podem mapear blocos de imagens e pixels para threads executando em paralelo. De fato muitos algoritmos fora do campo de processamento de imagem e video estão sendo acelerados pelo processamento de dados em paralelo, desde simulação física e computação finânceira até biologia computacional. Você pode encontrar diversos exemplos de aplicações e o ganho de performance que obtiveram aqui [3].
O modelo de programação CUDA foi projetado para expor todo o potencial de processamento paralelo as GPUs. Existem milhões de GPUs espalhadas por todo o mundo e você mesmo pode estar utilizando uma agora e nem sabe, confira em [4] a lista das placas gráficas que suportam CUDA.
Referências:
1. http://www.nvidia.com.br/object/cuda_home_br.html#
2. http://www-csl.csres.utexas.edu/~billmark/teach/cs395t-06-spring/
3. http://www.nvidia.com.br/object/cuda_develop_br.html
4. http://www.nvidia.com.br/object/cuda_learn_products_br.html
5. http://www.techradar.com/blogs/article/parallel-computing-and-you-496480
6. http://pt.wikipedia.org/wiki/Lei_de_moore
7. http://courses.ece.uiuc.edu/ece498/al1/Syllabus.html
8. http://courses.ece.uiuc.edu/ece498/al1/Archive/Spring2007/Syllabus.html
Computação de Alto Desempenho Utilizando Placas Gráficas
Publicado por: John em: 18 18UTC Dezembro 18UTC 2008
Esta foi uma apresentação que fiz durante o primeiro FreeComp (evento realizado pelo C.A de C.C da UCG), durante a palestra expliquei porquê está havendo a mudança de “one-core” para os manycore e multicore. Expliquei como é a arquitetura de uma GPU NVidia e o que é a tecnologia NVidia CUDA, dando alguns exemplos de código e aplicações que foram desenvolvidas utilizando-a. Para fechar discutimos um pouco sobre como será o processador do futuro, integração GPU, PPU e CPU.
Os slides que utilizei podem ser baixados aqui, qualquer dúvida ou sugestão pode ser postado aqui ou enviado
para meu e-mail.
Grande abraço, John.
A Internet e o Software Livre
Publicado por: John em: 2 02UTC Dezembro 02UTC 2008
O ser humano já criou coisas incríveis, e uma delas com certeza é a Internet [1].
Eu vejo a Internet como um grande livro onde toda a história da nossa sociedade está registrada, e o melhor de tudo isso é que ninguém é dono dela, ninguém pode destrui-la e TODOS podemos colaborar para que a cada dia que passe esse conhecimento aumente e se torne mais preciso.
O que você não consegue acessar hoje pela internet? Praticamente qualquer coisa você acha online e isso não se limita a textos em um idioma especifico, existem textos em latim, português, inglês japonês….
Me lembro de uma cena de Matrix onde o Neo senta em uma cadeira e plugam um fio em sua cabeça e as informações são “inseridas” em sua mente. Hoje você consegue aprender tudo ou quase tudo online desde como funciona um Elicoptero Apache até Meditação.
Tudo isso é responsabilidade de todos nós cuidar, somos nós que fazemos as coisas ficarem melhor a cada dia.
Sou fã de carteirinha do movimento de Software Livre, adoro a idéia de compartilhar conhecimento, a sensação de poder trabalhar com algo que você ama fazer e isso que você faz poder ajudar as pessoas a crescerem, ajuda-las a resolverem problemas é incomparável! E a Internet só vem a ajudar, escrevo um tutorial, um programa ou um texto de motivação em um canto do Brasil e outra pessoa pode lê-lo em qualquer parte do mundo! Isso é simplesmente fantástico!
Aprenda mais sobre:
Software Livre:
http://www.softwarelivre.org/whatisit.php
http://www.gnu.org/
[1] Internet:
http://pt.wikipedia.org/wiki/Internet
http://pt.wikipedia.org/wiki/World_Wide_Web
Grande abraço a todos!
Modelo de Domínio
Publicado por: John em: 16 16UTC Novembro 16UTC 2008
Apresento-lhes um resumo que fiz durante meus estudos para uma prova de Analise e Projeto de Sistemas. É bastante resumido, mas contém alguns pontos importantes que devem ser lembrados.
Resumo feito do capítulo 10 do livro do Craig Larman.
Introdução
Um modelo de domínio é amplamente utilizado como fonte de inspiração para projetar objetos de software e será um dado de entrada requerido por vários artefatos subsequentes. O modelo de domínio ilustra as classes conceituais significativas (para os modeladores) em um domínio de problema; é o artefato mais importante a ser criado durante a análise orientada a objetos1.
Identificar um conjunto rico de objetos ou de classes conceituais está no cerne da análise orientada a objetos e é um esforço que vale a pena pelo retorno que traz na fase de projeto e implementação.
Um modelo de domínio é uma representação de classes conceituais do mundo real, não de componentes de software. Ele não é um conjunto de diagramas que descreve classes ou objetos de software com responsabilidades.
Modelos de Domínio
O passo mais essencialmente orientado a objetos na análise ou na investigação é a decomposição de um domínio de interesse em classes conceituais e objetos individuais – os quais nos interessam. Um modelo de domínio é uma representação visual de classes conceituais, ou objetos do mundo real, em um domínio de problema. Usando a notação UML, um modelo de domínio é ilustrado como um conjunto de diagramas de classes, nos quais não se definem operações.
A informação que ela ilustra (usando a notação UML) poderia ter, de forma alternativa, sido transmitida por texto em prosa, por sentenças no Glossário ou em um outro lugar qualquer. Entretanto, é fácil compreender os elementos discretos e seus relacionamentos nesta linguagem visual.
Na análise estruturada, o critério para a decomposição são os processos ou as funções. Porém na análise orientada a objetos, a dimensão de decomposição usada é fundamentalmente realizada por meio de coisas ou entidades do domínio.
Identificação de Classes Conceituais
Nosso objetivo é criar um modelo de domínio composto de classes conceituais interessantes ou significativas no domínio de interessse.
Não pense que um modelo de domínio será melhor se tiver menos classes conceituais; a verdade tende a ser exatamente o oposto. É melhor especificar em excesso um modelo de domínio com muitas classes conceituais de granularidade fina do que subespecificá-lo.
Não exclua um conceito somente porque os requisitos não indicam uma necessidade óbvia de lembrar informações sobre ele ou, ainda, porque o conceito não tem atributos. É perfeitamente válido ter classes conceituais sem atributos, ou que têm um papel puramente comportamental no domínio, em vez de um papel de informação.
Estratégia para identificar classes conceituais
Uma técnica útil por sua simplicidade, é a análise linguistica: identificar os substantivos e as frases que podem estar no lugar de um substantivo, nas descrições textuais de um domínio de problema, e considerá-los como candidatos a classes conceituais ou atributos.
Porém deve-se tomar cuidado ao aplica reste método; não é possível um mapeamento mecânico de substantivos para classes conceituais, e as palavras em uma linguagem natural tendem a ser ambíguas.
O modelo de domínio é uma visualização de conceitos e de vocabulário do domínio dignos de nota. Onde eles se encontram? Nos casos de uso. Assim, eles representam uma rica fonte a ser explorada pela identificação de frases nominais (substantivos ou frases que podem, em uma sentençã, ocupar o lugar de um substantivo).
Uma dica para diferenciar classes conceituais de atributos
Talvez o engano mais comum na criação de um modelo de domínio seja representar algo como um atributo quando ele deve ser um conceito. Uma regra prática para ajudar a evitar esse engano é a seguinte:
Se você consegue pensar em uma classe conceitual X como um número ou um texto no mundo real, então X provavelmente será um atributo, e não uma classe conceitual.
1. Os casos de uso são um artefato importante da análise de requisitos, porém não são realmente orientados a objetos. Eles enfatizam uma visão de processo de domínio.Desenvolvimendo com CUDA no Ubuntu 8.04
Publicado por: John em: 25 25UTC Outubro 25UTC 2008
Olá.
Estou escrevendo este post porquê já a algum tempo estava procurando um bom tutorial de como instalar a biblioteca CUDA no ubuntu 8.04 (Hardy Heron) e por fim encontrei este excelente tutorial: CUDA Development in Ubuntu e o que estarei apresentando aqui para vocês é a minha tradução e interpretação deste artigo que julguei ser de ótima qualidade.
O que está em verde são linhas de comando você pode copia-las e colar (ctrl+shift) em seu terminal que funcionará.
# Parte 1
# Instalando os pacotes básicos de programação no ubuntu
sudo apt-get install build-essential libglut3-dev -y
# Instalando o driver da NVidia
# a partir do site oficial da nvidia (utilizou-se o wget mas você pode baixar diretamente do site)
wget http://developer.download.nvidia.com/compute/cuda/2_0/linux/driver/NVIDIA-Linux-x86-177.67-pkg1.run
# Tornando o arquivo que foi baixado, executável
chmod +x ./NVIDIA-Linux-x86-177.67-pkg1.run
# Este comando irá fechar o seu ambiente gráfico, a instalação do driver requer isso.
sudo /etc/init.d/gdm stop
# Instale o driver; na minha máquina eu fui questionado se desejava baixar uma versão do kernel
# pre-compilada, confirmei que sim porém não baixou e o programa de instalação criou uma versão
# locamente e a utilizou.
sudo ./NVIDIA-Linux-x86-177.67-pkg1.run
# Inicialize novamente a interface gráfica
sudo /etc/init.d/gdm start
# Este passo é para resolver um conflito de drivers; se não o fizermos a máquina entrar em um modo
# gráfico pobre ao ser reiniciada.
sudo gedit /etc/default/linux-restricted-modules-common
# Mude/Adicione (separado por espaço) o texto DISABLED_MODULES(” “) para DISABLED_MODULES(”nv”)
# Parte 2
# Instalando o CUDA Toolkit
wget http://developer.download.nvidia.com/compute/cuda/2_0/linux/toolkit/NVIDIA_CUDA_Toolkit_2.0_ubuntu7.10_x86.run
chmod +x NVIDIA_CUDA_Toolkit_2.0_ubuntu7.10_x86.run
sudo ./NVIDIA_CUDA_Toolkit_2.0_ubuntu7.10_x86.run auto
# Configurando as variáveis de ambiente (digite exatamente o que está abaixo, digite logado no usuário que irá compilar os programas – após esse passo reinicie seu terminal)
echo “# CUDA stuff
PATH=\$PATH:/usr/local/cuda/bin
LD_LIBRARY_PATH=\$LD_LIBRARY_PATH:/usr/local/cuda/lib
export PATH
export LD_LIBRARY_PATH” >> ~/.bashrc
# Parte 3
# Instalando o CUDA SDK (Pressione enter em ambas as perguntas para confirmar o diretório padrão)
wget http://developer.download.nvidia.com/compute/cuda/2_0/linux/sdk/NVIDIA_CUDA_SDK_2.02.0807.1535_linux.run
chmod +x ./NVIDIA_CUDA_SDK_2.02.0807.1535_linux.run
./NVIDIA_CUDA_SDK_2.02.0807.1535_linux.run
# Parte 4
# Compile e execute um exemplo para ficar admirado! 
cd ~/NVIDIA_CUDA_SDK/
make
~/NVIDIA_CUDA_SDK/bin/linux/release/nbody
nbody
# Parte 5
# Instalar o configurador do driver da NVidia
sudo apt-get install nvidia-settings
# Parte 6
# O Compiz as vezes entra em conflito com o CUDA, para evitar isso desabilite os efeitos visuais
# Sistema -> Preferencias -> Aparencia -> Efeitos Visuais -> Nenhum
# Parte 7
# Alguns exemplos legais
~/NVIDIA_CUDA_SDK/bin/linux/release/nbody
~/NVIDIA_CUDA_SDK/bin/linux/release/particles
~/NVIDIA_CUDA_SDK/bin/linux/release/oceanFFT
~/NVIDIA_CUDA_SDK/bin/linux/release/simpleGL
Se os efeitos parecerem estar dando saltos (algo como lag) pode ser porquê a taxa de quadros por segundo do exemplo não está sincronizada com a do monitor, para corrigir isto habilite a opção “Sync to VBlank”:
Sistema -> Administração -> NVIDIA X Server Settings -> X Screen 0 -> OpenGL Settings -> marque “Sync VBlank”.
# Parte 8
# Comece a programar em CUDA!
Uma forma fácil de criar seu primeiro projeto em CUDA é através do modelo que vem com o SDK. Execute estes comandos para criar um projeto com base no modelo:
cd ~/NVIDIA_CUDA_SDK/projects
cp -r template/ myproject
Crie o projeto dentro da pasta do SDK porquê ele possui dependencias e manter a estrutura de pastas é importante!
Altere o Makefile
cd myproject
gedit Makefile
Mude as linhas:
# Add source files here
EXECUTABLE := template
Para:
# Add source files here
EXECUTABLE := myproject
Para rodar o projeto em modo emulado:
make emu=1
Ou para rodar direto na GPU:
make
Ponha o menino para rodar:
~/NVIDIA_CUDA_SDK/bin/linux/emurelease/myproject
Ou
~/NVIDIA_CUDA_SDK/bin/linux/release/myproject
Bem é isso ae pessoal, aqui na minha máquina funcionou de primeira, qualquer dúvida que tiverem postem ae que talvez eu possa ajudar ou alguém mais experiente possa. Se encontrarem alguma forma mais rápida para instalar me enviem o link que eu colocarei aqui.
Existem alguns sites e tutoriais muito bons na internet que podem ser utilizado como um guia para o aprendizado eis alguns:
http://forums.nvidia.com/
http://www.ddj.com/architect/207200659
http://llpanorama.wordpress.com/2008/06/11/threads-and-blocks-and-grids-oh-my/
http://llpanorama.wordpress.com/2008/05/21/my-first-cuda-program/
Obrigado pela leitura e espero que seja útil!
C Perguntas Frequentes – FAQ
Publicado por: John em: 24 24UTC Outubro 24UTC 2008
Achei esse site[1] muito interessante, tem diversas questõs a respeito da linguagem C que eu não saberia responder sem uma pesquisa. Vale a pena dar uma lida!
Have fun!
Método string::append
Publicado por: John em: 21 21UTC Outubro 21UTC 2008
O método append é utilizando que você deseja adicionar uma outra string ao final de uma string existente, possuí os construtores abaixo:
string& append ( const string& str );
Adicionar str ao final da string original.
string& append ( const string& str, size_t pos, size_t n );
Adiciona uma substring de str ao final da string original. A substring inicia-se em pos e copia os próximos n caracteres.
string& append ( const char * s, size_t n );
Adiciona os n primeiros caracteres da string s (C-style) ao final da string original.
string& append ( const char * s );
Adiciona a string s (C-style) ao final da string original.
string& append ( size_t n, char c );
Adiciona o caractere c repetido n vezes ao final da string original.
template<class InputIterator> string& append (InputIterator first, InputIterator last);
Adiciona os caracteres no intervalo first-last ao final da string original.
Exemplo:
// appending to string #include <iostream> #include <string> using namespace std; int main() { string str; string str2 = "Writing "; string str3 = "print 10 and then 5 more"; str.append(str2); str.append(str3, 6, 3); str.append("dots are cool", 5); str.append("here: "); str.append(10, '.'); str.append(str3.begin()+8, str3.end()); str.append<int>(5, 0x2E); cout << str << endl; return 0; }
Saída:
Writing 10 dots here: .......... and then 5 more.....
Velha infancia – Desenhos
Publicado por: John em: 19 19UTC Outubro 19UTC 2008
Eae Galera!!!!
Esse final de semana bateu aquela saudade da minha infância… da época em que chegava em casa assitia os desenhos e depois saia para encontrar com a turma do bairro para jogar bola e comentar sobre os desenhos….
Pesquisei no you tube todos os desenhos que eu consegui lembrar que eu assistia quando era criança (e as vezes ainda assisto ehhehe), tá ai em baixo a lista completa; Tem desde Jaspion, He man, tunder cats até Dragon Ball Z, Samurai X e outros. Valew a pena assitir TODOS Digam quais são seus preferidos!! Aquele abraço!!!
Dragon Ball Z – Segunda Abertura
http://br.youtube.com/watch?v=83ql2LLquZ4&feature=related
Dragon Ball – Abertura
http://br.youtube.com/watch?v=HUhPruarHrA
Muppets Baby – Opening
http://br.youtube.com/watch?v=62vzhPXQuJU
Jaspion – Abertura Brasileira
http://br.youtube.com/watch?v=R-vmzH4TPXQ
Fly, o Pequeno Guerreiro – Abertura Brasileira
http://br.youtube.com/watch?v=YmCuZml5qbc&feature=related
desenhos animados smurfs
http://br.youtube.com/watch?v=kk9KvI0dC6Q
Samurai X abertura legendada (rurouni kenshin)
http://br.youtube.com/watch?v=8634PdHovpM&feature=related
Saudades de uma infância verdadeiramente feliz!
http://br.youtube.com/watch?v=rd4uTRKmrUU&feature=related
Megaman abertura brasileira
http://br.youtube.com/watch?v=j6-E_Gp5ZyM&feature=related
Mega man
http://br.youtube.com/watch?v=j6-E_Gp5ZyM&feature=related
Digimon abertura
http://br.youtube.com/watch?v=n6EqPoGZ5Zo
The Jetsons Tv Intro
http://br.youtube.com/watch?v=DFbuulDiM_U
Os Flintstones 1ª Abertura
http://br.youtube.com/watch?v=eYkMk1MFGig&feature=related
He man
http://br.youtube.com/watch?v=-IaEaj-Jrbw
Power Rangers Ano 1
http://br.youtube.com/watch?v=SEe5YJxlQNw
Doug Funnie
http://br.youtube.com/watch?v=5fXDlzHuZPc
Super Patos (abertura brasileira)
http://br.youtube.com/watch?v=mymSBpgu66E
Corrida Maluca
http://www.youtube.com/watch?v=thvlayZd3GA
Cavaleiros do Zodiaco
http://www.youtube.com/watch?v=WCV74ZtLx6I
Manda-Chuva – Arranhador De Violinos
http://www.youtube.com/watch?v=0-UVznYBilA&feature=related
Classe string::string – construtores
Publicado por: John em: 18 18UTC Outubro 18UTC 2008
Olá. Iniciarei hoje uma série de posts sobre a linguagem C++; começarei descrevendo a classe string. Na maior parte do tempo o que estarei fazendo é traduzir os textos encontrados no site cplusplus.com. Todos estes métodos alocam memória para um objeto string e inicializam o seu conteúdo. Os construtores que existem para a classe são:
explicit string();
O conteúdo da string é inicializado com uma string vazia “”.
string ( const string& str );
O conteúdo da string é inicializado com uma copia da string passada como parâmetro.
string ( const string& str, size_t pos, size_t n = npos );
O conteúdo da string é inicializado com uma substring de str. A substring utilizada é a parte de str que inicia na posição pos e tem n caracteres de comprimento se não ouver quantidade de caracteres suficientes em str obtem até o último caractere.
string ( const char * s, size_t n );
O conteúdo da string é inicializado com uma copia dos n primeiros caracteres da string (C-style) apontada por s.
string ( const char * s );
O conteúdo da string é inicializado com uma copia (C-style) da string apontada por s.
string ( size_t n, char c );
O conteúdo da string é inicializado o caractere c repetido n vezes.
template<class InputIterator> string (InputIterator begin, InputIterator end);
Se begin e/ou end é um inteiro então é efetuado um cast para que o construtor citado acima seja utilizado, tornando-se então: string(static_cast<size_t>(begin),static_cast<char>(end)); De outra forma os parametros são utilizados para selecionar os caracteres que serão utilizados para inicializar a string, o último caracter da string será o caractere apontado por end-1.
Parâmetros:
str Outro objeto da classe string que será utilizado para inicializar o objeto atual.
pos Posição inicial da substring de str que será utilizada para inicializar o novo objeto, iniciando na posição 0. Se este valor exceder o tamanho de str uma exceção será disparada (out_of_range exception).
n Número de caracteres que o novo objeto terá. Para o terceiro construtor o valor padrão deste parâmetro é npos. npos é uma constante com o maior valor possível para uma variável do tipo size_t. No caso padrão, todos os caracteres de str serão copiados.
s Array com uma sequência de caracteres. No quarto construtor a quantidade de caracteres que serão copiados será n mesmo se a string original conter caracteres null (\n), porém o quinto construtor é baseado no caractere null (\n). c Valor de um caractere que deverá ser utilizado para inicializar a string. Este caractere será repetido n vezes.
begin Se jutamente com end, ambos forem inteiros, será equivalente a utilizar o parâmetro n, de outra forma será considerado com o um iterator referindo-se ao inicio de uma sequência de caracteres.
end Se jutamente com begin, ambos forem inteiros, será equivalente a utilizar o parâmetro n, de outra forma será considerado com o um iterator referindo-se ao fim de uma sequência de caracteres.
Exemplo:
// string constructor #include <iostream> #include <string> using namespace std; int main () { string s0 ("Initial string"); // constructors used in the same order as described above: string s1; string s2 (s0); string s3 (s0, 8, 3); string s4 ("A character sequence", 6); string s5 ("Another character sequence"); string s6 (10, 'x'); string s7a (10, 42); string s7b (s0.begin(), s0.begin()+7); cout << "s1: " << s1 << "\ns2: " << s2 << "\ns3: " << s3; cout << "\ns4: " << s4 << "\ns5: " << s5 << "\ns6: " << s6; cout << "\ns7a: " << s7a << "\ns7b: " << s7b << endl; return 0; }
Saída:
s1: s2: Initial string s3: str s4: A char s5: Another character sequence s6: xxxxxxxxxx s7a: ********** s7b: Initial
Este primeiro post foi básico mas é para servir de aquecimento, espero que algum dia seja util para alguém. Até a próxima. John!
