diff options
Diffstat (limited to 'pt-br')
| -rw-r--r-- | pt-br/qt-pt.html.markdown | 174 | ||||
| -rw-r--r-- | pt-br/rust-pt.html.markdown | 332 |
2 files changed, 506 insertions, 0 deletions
diff --git a/pt-br/qt-pt.html.markdown b/pt-br/qt-pt.html.markdown new file mode 100644 index 00000000..99579c35 --- /dev/null +++ b/pt-br/qt-pt.html.markdown @@ -0,0 +1,174 @@ +--- +category: tool +tool: Qt Framework +language: c++ +filename: learnqt-pt.cpp +contributors: + - ["Aleksey Kholovchuk", "https://github.com/vortexxx192"] +translators: + - ["Lucas Pugliesi", "https://github.com/fplucas"] +lang: pt-br +--- + +**Qt** é amplamente conhecido como um framework para desenvolvimento de +software multi-plataforma que pode rodar em vários outras plataformas de +softwares e hardwares com pouca ou nenhuma alteração no código, enquanto mantém +o poder e a velocidade de uma aplicação nativa. Embora o **Qt** tenha sido +originalmente escrito em *C++*, é possível utilizá-lo em outras linguagens: +*[PyQt](https://learnxinyminutes.com/docs/pyqt/)*, *QtRuby*, *PHP-Qt*, etc. + +**Qt** é ótimo para criar aplicações com interface gráfica (GUI). Esse tutorial +será feito em *C++*. + +```c++ +/* + * Vamos começar + */ + +// Todos as dependências do framework Qt iniciam com a letra 'Q' maiúscula +#include <QApplication> +#include <QLineEdit> + +int main(int argc, char *argv[]) { + // Cria um objeto para utilizar todos os recursos da aplicação + QApplication app(argc, argv); + + // Cria um widget com linha editável e exibe na tela + QLineEdit lineEdit("Hello world!"); + lineEdit.show(); + + // Inicia a aplicação em um evento de loop + return app.exec(); +} +``` + +A parte gráfica do **Qt** é toda composta de *widgets* e *conexões* entre eles. + +[LEIA MAIS SOBRE WIDGETS](http://doc.qt.io/qt-5/qtwidgets-index.html) + +```c++ +/* + * Vamos criar um label e um botão. + * Um label irá aparecer quando o botão for clicado + * + * O próprio código do Qt é autoexplicativo. + */ + +#include <QApplication> +#include <QDialog> +#include <QVBoxLayout> +#include <QPushButton> +#include <QLabel> + +int main(int argc, char *argv[]) { + QApplication app(argc, argv); + + QDialog dialogWindow; + dialogWindow.show(); + + // Adiciona um layout vertical + QVBoxLayout layout; + dialogWindow.setLayout(&layout); + + QLabel textLabel("Thanks for pressing that button"); + layout.addWidget(&textLabel); + textLabel.hide(); + + QPushButton button("Press me"); + layout.addWidget(&button); + + // Exibe o label oculto quando o botão é clicado + QObject::connect(&button, &QPushButton::pressed, + &textLabel, &QLabel::show); + + return app.exec(); +} +``` + +Veja o *QObject::connect*. O método é usado para conectar o *SINAL* de um objeto +ao *ENCAIXE* outro. + +**Sinais** são emitidos quando algo ocorre com o objeto, como quando o sinal de +*clique* é acionado apertando o QPushButton. + +**Encaixes** são *ações* que são executadas em resposta aos sinais recebidos. + +[LEIA MAIS SOBRE SINAIS E ENCAIXES](http://doc.qt.io/qt-5/signalsandslots.html) + + +A seguir vamos aprender como usar não somente o comportamento padrão dos +widgets, mas também extender seus comportamentos usando herança. Vamos criar um +botão e contar quantas vezes é pressionado. Para esse propósito definiremos +nossa própria classe *CounterLabel*. Ela deve ser declarada em um arquivo +diferente devido a estrutura específica do Qt. + +```c++ +// counterlabel.hpp + +#ifndef COUNTERLABEL +#define COUNTERLABEL + +#include <QLabel> + +class CounterLabel : public QLabel { + Q_OBJECT // Define os macros presente em todo objeto Qt + +public: + CounterLabel() : counter(0) { + setText("Counter has not been increased yet"); // método do QLabel + } + +public slots: + // Ação que será chamada em resposta ao clique do botão + void increaseCounter() { + setText(QString("Counter value: %1").arg(QString::number(++counter))); + } + +private: + int counter; +}; + +#endif // COUNTERLABEL +``` + +```c++ +// main.cpp +// Quase igual ao exemplo anterior + +#include <QApplication> +#include <QDialog> +#include <QVBoxLayout> +#include <QPushButton> +#include <QString> +#include "counterlabel.hpp" + +int main(int argc, char *argv[]) { + QApplication app(argc, argv); + + QDialog dialogWindow; + dialogWindow.show(); + + QVBoxLayout layout; + dialogWindow.setLayout(&layout); + + CounterLabel counterLabel; + layout.addWidget(&counterLabel); + + QPushButton button("Push me once more"); + layout.addWidget(&button); + QObject::connect(&button, &QPushButton::pressed, + &counterLabel, &CounterLabel::increaseCounter); + + return app.exec(); +} +``` + +É isso! Claro, o framework Qt é muito maior do que exemplificamos no tutorial, +então esteja preparado para ler e praticar mais. + +## Leitura complementar + +- [Tutoriais Qt 4.8](http://doc.qt.io/qt-4.8/tutorials.html) +- [Tutoriais Qt 5](http://doc.qt.io/qt-5/qtexamplesandtutorials.html) + +Boa sorte e divirta-se! diff --git a/pt-br/rust-pt.html.markdown b/pt-br/rust-pt.html.markdown new file mode 100644 index 00000000..8134d3c5 --- /dev/null +++ b/pt-br/rust-pt.html.markdown @@ -0,0 +1,332 @@ +--- +language: rust +filename: rust-pt.rs +contributors: + - ["Paulo Henrique Rodrigues Pinheiro", "https://about.me/paulohrpinheiro"] +lang: pt-br + +--- + +Rust é uma linguagem de programação desenvolvida pelo Mozilla Research. Rust +combina controle de baixo nível sobre o desempenho com facilidades de alto +nível e garantias de segurança. + +Ele atinge esse objetico sem necessitar de um coletor de lixo ou um processo +*runtime*, permitindo que se use bibliotecas Rust em substituição a bibliotecas +em C. + +A primeira versão de Rust, 0.1, apareceu em janeiro de 2012, e por três anos o +desenvolvimento correu tão rapidamente que que até recentemente o uso de +versões estáveis foi desencorajado e em vez disso a recomendação era usar as +versões empacotadas toda noite. + +Em 15 de maio de 2015, a versão 1.0 de Rust foi liberada com a garantia total +de compatibilidade reversa. Melhorias no tempo de compilação e em outros +aspectos do compilador estão disponíveis atualmente nas versões empacotadas à +noite. Rust adotou um modelo de versões *train-based* com novas versões +regularmente liberadas a cada seis semanas. A versão 1.1 beta de Rust foi +disponibilizada ao mesmo tempo que a versão 1.0. + +Apesar de Rust ser uma linguagem mais e baixo nível, Rust tem alguns conceitos +funcionais geralmente encontradas em linguagens de alto nível. Isso faz Rust +não apenas rápido, mas também fácil e eficiente para programar. + +```rust +// Isso é um comentário. Linhas de comentários são assim... +// e múltiplas linhas se parecem assim. + +/// Comentários para documentação são assim e permitem notação em markdown. +/// # Exemplos +/// +/// ``` +/// let five = 5 +/// ``` + +/////////////// +// 1. Básico // +/////////////// + +// Funções +// `i32` é o tipo para inteiros com sinal de 32 bits +fn add2(x: i32, y: i32) -> i32 { + // Implicit return (no semicolon) + x + y +} + +// Função main +fn main() { + // Números // + + // Immutable bindings + let x: i32 = 1; + + // Inteiros/Sufixos para ponto flutuante + let y: i32 = 13i32; + let f: f64 = 1.3f64; + + // Inferência de tipos + // Em geral, o compilador Rust consegue inferir qual o tipo de uma + // variável, então você não tem que escrever uma anotação explícita de tipo. + // Ao longo desse tutorial, os tipos serão explicitamente anotados em + // muitos lugares, mas apenas com propóstico demonstrativo. A inferência de + // tipos pode gerenciar isso na maioria das vezes. + let implicit_x = 1; + let implicit_f = 1.3; + + // Aritmética + let sum = x + y + 13; + + // Variáveis mutáveis + let mut mutable = 1; + mutable = 4; + mutable += 2; + + // Strings // + + // String literais + let x: &str = "hello world!"; + + // Imprimindo + println!("{} {}", f, x); // 1.3 hello world + + // Uma `String` – uma String alocada no heap + let s: String = "hello world".to_string(); + + // Uma String slice - uma visão imutável em outra string. + // Basicamente, isso é um par imutável de ponteiros para uma string - ele + // não contém o conteúdo de uma strinf, apenas um ponteiro para o começo e + // um ponteiro para o fim da área de memória para a string, estaticamente + // alocada ou contida em outro objeto (nesse caso, `s`) + let s_slice: &str = &s; + + println!("{} {}", s, s_slice); // hello world hello world + + // Vetores/arrays // + + // Um array de tamanho fixo + let four_ints: [i32; 4] = [1, 2, 3, 4]; + + // Um array dinâmico (vetor) + let mut vector: Vec<i32> = vec![1, 2, 3, 4]; + vector.push(5); + + // Uma fatia – uma visão imutável em um vetor ou array + // Isso é como um string slice, mas para vetores + let slice: &[i32] = &vector; + + // Use `{:?}` para imprimir alguma coisa no estilo de depuração + println!("{:?} {:?}", vector, slice); // [1, 2, 3, 4, 5] [1, 2, 3, 4, 5] + + // Tuplas // + + // Uma tupla é um conjunto de tamanho fixo de valores de tipos + // possivelmente diferentes + let x: (i32, &str, f64) = (1, "hello", 3.4); + + // Desestruturando `let` + let (a, b, c) = x; + println!("{} {} {}", a, b, c); // 1 hello 3.4 + + // Indexando + println!("{}", x.1); // hello + + ////////////// + // 2. Tipos // + ////////////// + + // Struct + struct Point { + x: i32, + y: i32, + } + + let origin: Point = Point { x: 0, y: 0 }; + + // Uma estrutura com campos sem nome, chamada 'estrutura em tupla' + struct Point2(i32, i32); + + let origin2 = Point2(0, 0); + + // enum básico com na linguagem C + enum Direction { + Left, + Right, + Up, + Down, + } + + let up = Direction::Up; + + // Enum com campos + enum OptionalI32 { + AnI32(i32), + Nothing, + } + + let two: OptionalI32 = OptionalI32::AnI32(2); + let nothing = OptionalI32::Nothing; + + // Generics // + + struct Foo<T> { bar: T } + + // Isso é definido na biblioteca padrão como um `Option` + enum Optional<T> { + SomeVal(T), + NoVal, + } + + // Methods // + + impl<T> Foo<T> { + // Métodos recebem um parâmetro `self` explícito + fn get_bar(self) -> T { + self.bar + } + } + + let a_foo = Foo { bar: 1 }; + println!("{}", a_foo.get_bar()); // 1 + + // Traits (conhecidos como interfaces ou typeclasses em outras linguagens)// + + trait Frobnicate<T> { + fn frobnicate(self) -> Option<T>; + } + + impl<T> Frobnicate<T> for Foo<T> { + fn frobnicate(self) -> Option<T> { + Some(self.bar) + } + } + + let another_foo = Foo { bar: 1 }; + println!("{:?}", another_foo.frobnicate()); // Some(1) + + ////////////////////////////////// + // 3. Reconhecimento de padrões // + ////////////////////////////////// + + let foo = OptionalI32::AnI32(1); + match foo { + OptionalI32::AnI32(n) => println!("it’s an i32: {}", n), + OptionalI32::Nothing => println!("it’s nothing!"), + } + + // Reconhecimento avançado de padrões + struct FooBar { x: i32, y: OptionalI32 } + let bar = FooBar { x: 15, y: OptionalI32::AnI32(32) }; + + match bar { + FooBar { x: 0, y: OptionalI32::AnI32(0) } => + println!("The numbers are zero!"), + FooBar { x: n, y: OptionalI32::AnI32(m) } if n == m => + println!("The numbers are the same"), + FooBar { x: n, y: OptionalI32::AnI32(m) } => + println!("Different numbers: {} {}", n, m), + FooBar { x: _, y: OptionalI32::Nothing } => + println!("The second number is Nothing!"), + } + + ////////////////////////// + // 4. Controle de fluxo // + ////////////////////////// + + // `for` laços de repetição/iteração + let array = [1, 2, 3]; + for i in array.iter() { + println!("{}", i); + } + + // Ranges + for i in 0u32..10 { + print!("{} ", i); + } + println!(""); + // prints `0 1 2 3 4 5 6 7 8 9 ` + + // `if` + if 1 == 1 { + println!("Maths is working!"); + } else { + println!("Oh no..."); + } + + // `if` como expressão + let value = if true { + "good" + } else { + "bad" + }; + + // laço `while` de repetição + while 1 == 1 { + println!("The universe is operating normally."); + } + + // Repetição infinita + loop { + println!("Hello!"); + } + + //////////////////////////////////////// + // 5. Proteção de memória & ponteiros // + //////////////////////////////////////// + + // Ponteiro com dono - somente uma coisa pode 'possuir' esse ponteiro por + // vez. + // Isso significa que quando `Box` perde seu escopo, ele pode ser + // automaticamente desalocado com segurança. + let mut mine: Box<i32> = Box::new(3); + *mine = 5; // dereference + // Aqui, `now_its_mine` possui o controle exclusivo de `mine`. Em outras + // palavras, `mine` tem o controle transferido. + let mut now_its_mine = mine; + *now_its_mine += 2; + + println!("{}", now_its_mine); // 7 + // println!("{}", mine); // não compila porque `now_its_mine` é o dono + + // Referência - um ponteiro imutável que referencia outro dado + // Quando uma referência é dada a um valor, nós dizemos que o valor foi + // emprestado 'borrowed'. + // Quando um valor é emprestado sem ser mutável, ele não pode ser alterado + // ou ter a sua propriedade transferida. + // Um empréstimo finaliza quando o escopo em que ele foi criado termina. + + let mut var = 4; + var = 3; + let ref_var: &i32 = &var; + + println!("{}", var); // AO contrário de `mine`, `var` ainda pode ser usado + println!("{}", *ref_var); + // var = 5; // não compila porque `var` é emprestado + // *ref_var = 6; // não compila, porque `ref_var` é uma referência imutável + + // Referência mutável + // Quando um valor mutável é emprestado, ele não pode ser acessado. + let mut var2 = 4; + let ref_var2: &mut i32 = &mut var2; + *ref_var2 += 2; // '*' aponta para var2, que é mutável e emprestada + + println!("{}", *ref_var2); // 6 , // var2 não compila. + // ref_var2 é do tipo &mut i32, que guarda uma referência i32, não o valor. + // var2 = 2; // não compila porque `var2` é empretada. +} +``` + +## Outras leituras + +Existe muita coisa sobre Rust - isto aqui é apenas o básico para que você possa +entender as coisas mais importantes. Para aprender mais sobre Rust, leia [The +Rust Programming Language](http://doc.rust-lang.org/book/index.html) e +acompanhe [/r/rust](http://reddit.com/r/rust). A galera no canal #rust do +irc.mozilla.org também estão sempre dispostos a ajudar os novatos. + +Você pode brincar com outras característica de Rust com um compilador online +no portal oficial do projeto [Rust playpen](http://play.rust-lang.org), or ler +mais na página oficial [Rust website](http://rust-lang.org). + +No Brasil acompanhe os encontros do [Meetup Rust São Paulo] +(http://www.meetup.com/pt-BR/Rust-Sao-Paulo-Meetup/). + |