From e2606bb26259f702e6359afa4075c8a081fb7600 Mon Sep 17 00:00:00 2001 From: elf Date: Fri, 26 Dec 2014 08:56:36 -0200 Subject: general translation to pt-br for common-lisp completed --- pt-br/common-lisp-pt.html.markdown | 636 +++++++++++++++++++++++++++++++++++++ 1 file changed, 636 insertions(+) create mode 100644 pt-br/common-lisp-pt.html.markdown (limited to 'pt-br') diff --git a/pt-br/common-lisp-pt.html.markdown b/pt-br/common-lisp-pt.html.markdown new file mode 100644 index 00000000..a2506aec --- /dev/null +++ b/pt-br/common-lisp-pt.html.markdown @@ -0,0 +1,636 @@ +--- + +language: "Common Lisp" +filename: commonlisp.lisp +contributors: + - ["Paul Nathan", "https://github.com/pnathan"] +--- + + + + + +ANSI Common Lisp é uma linguagem de uso geral, multi-paradigma, designada +para uma variedade de aplicações na indústria. É frequentemente citada +como uma linguagem de programação programável. + + + + +O ponto inicial clássico é [Practical Common Lisp and freely available.](http://www.gigamonkeys.com/book/) + + + + +Outro livro recente e popular é o +[Land of Lisp](http://landoflisp.com/). + + +```common_lisp + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;; 0. Sintaxe +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; "Form" Geral + + + + +;; Lisp tem dois pedaços fundamentais de sintaxe: o ATOM e S-expression. +;; Tipicamente, S-expressions agrupadas são chamadas de `forms`. + + +10 ; um atom; é avaliado para ele mesmo + + + +:THING ;Outro atom; avaliado para o símbolo :thing. + + + +t ; outro atom, denotado true. + + + +(+ 1 2 3 4) ; uma s-expression + +'(4 :foo t) ;outra s-expression + + +;;; Comentários + +;; Comentários de uma única linha começam com ponto e vírgula; usar dois para +;; comentários normais, três para comentários de seção, e quadro para comentários +;; em nível de arquivo. + +#| Bloco de comentário + pode abranger várias linhas e... + #| + eles podem ser aninhados + |# +|# + +;;; Ambiente + +;; Existe uma variedade de implementações; a maioria segue o padrão. +;; CLISP é um bom ponto de partida. + +;; Bibliotecas são gerenciadas através do Quicklisp.org's Quicklisp systemm. + +;; Common Lisp é normalmente desenvolvido com um editor de texto e um REPL +;; (Read Evaluate Print Loop) rodando ao mesmo tempo. O REPL permite exploração +;; interativa do programa como ele é "ao vivo" no sistema. + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;; 1. Tipos Primitivos e Operadores +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; Símbolos + +'foo ; => FOO Perceba que um símbolo é automáticamente convertido para maíusculo. + +;; Intern manualmente cria um símbolo a partir de uma string. + +(intern "AAAA") ; => AAAA + +(intern "aaa") ; => |aaa| + +;;; Números +9999999999999999999999 ; inteiro +#b111 ; binário => 7 +#o111 ; octal => 73 +#x111 ; hexadecimal => 273 +3.14159s0 ; single +3.14159d0 ; double +1/2 ; ratios +#C(1 2) ; números complexos + + +;; Funções são escritas como (f x y z ...) +;; onde f é uma função e x, y, z, ... são operadores +;; Se você quiser criar uma lista literal de dados, use ' para evitar +;; que a lista seja avaliada - literalmente, "quote" os dados. +'(+ 1 2) ; => (+ 1 2) +;; Você também pode chamar uma função manualmente: +(funcall #'+ 1 2 3) ; => 6 +;; O mesmo para operações aritiméticas +(+ 1 1) ; => 2 +(- 8 1) ; => 7 +(* 10 2) ; => 20 +(expt 2 3) ; => 8 +(mod 5 2) ; => 1 +(/ 35 5) ; => 7 +(/ 1 3) ; => 1/3 +(+ #C(1 2) #C(6 -4)) ; => #C(7 -2) + + ;;; Booleans +t ; para true (qualquer valor não nil é true) +nil ; para false - e para lista vazia +(not nil) ; => t +(and 0 t) ; => t +(or 0 nil) ; => 0 + + ;;; Caracteres +#\A ; => #\A +#\λ ; => #\GREEK_SMALL_LETTER_LAMDA +#\u03BB ; => #\GREEK_SMALL_LETTER_LAMDA + +;;; String são arrays de caracteres com tamanho fixo. +"Hello, world!" +"Benjamin \"Bugsy\" Siegel" ; barra é um escape de caracter + +;; String podem ser concatenadas também! +(concatenate 'string "Hello " "world!") ; => "Hello world!" + +;; Uma String pode ser tratada como uma sequência de caracteres +(elt "Apple" 0) ; => #\A + +;; format pode ser usado para formatar strings +(format nil "~a can be ~a" "strings" "formatted") + +;; Impimir é bastante fácil; ~% indica nova linha +(format t "Common Lisp is groovy. Dude.~%") + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 2. Variáveis +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Você pode criar uma global (escopo dinâmico) usando defparameter +;; um nome de variável pode conter qualquer caracter, exceto: ()",'`;#|\ + +;; Variáveis de escopo dinâmico devem ter asteriscos em seus nomes! + +(defparameter *some-var* 5) +*some-var* ; => 5 + +;; Você pode usar caracteres unicode também. +(defparameter *AΛB* nil) + + +;; Acessando uma variável anteriormente não ligada é um +;; comportamento não definido (mas possível). Não faça isso. + +;; Ligação local: `me` é vinculado com "dance with you" somente dentro +;; de (let ... ). Let permite retornar o valor do último `form` no form let. + +(let ((me "dance with you")) + me) +;; => "dance with you" + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 3. Estruturas e Coleções +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Estruturas +(defstruct dog name breed age) +(defparameter *rover* + (make-dog :name "rover" + :breed "collie" + :age 5)) +*rover* ; => #S(DOG :NAME "rover" :BREED "collie" :AGE 5) + +(dog-p *rover*) ; => t ;; ewww) +(dog-name *rover*) ; => "rover" + +;; Dog-p, make-dog, and dog-name foram todas criadas por defstruct! + +;;; Pares +;; `cons' constroi pares, `car' and `cdr' extrai o primeiro +;; e o segundo elemento +(cons 'SUBJECT 'VERB) ; => '(SUBJECT . VERB) +(car (cons 'SUBJECT 'VERB)) ; => SUBJECT +(cdr (cons 'SUBJECT 'VERB)) ; => VERB + +;;; Listas + +;; Listas são estruturas de dados do tipo listas encadeadas, criadas com `cons' +;; pares e terminam `nil' (ou '()) para marcar o final da lista +(cons 1 (cons 2 (cons 3 nil))) ; => '(1 2 3) +;; `list' é um construtor conveniente para listas +(list 1 2 3) ; => '(1 2 3) +;; e a quote (') também pode ser usado para um valor de lista literal +'(1 2 3) ; => '(1 2 3) + +;; Ainda pode-se usar `cons' para adicionar um item no começo da lista. +(cons 4 '(1 2 3)) ; => '(4 1 2 3) + +;; Use `append' para - surpreendentemente - juntar duas listas +(append '(1 2) '(3 4)) ; => '(1 2 3 4) + +;; Ou use concatenate - + +(concatenate 'list '(1 2) '(3 4)) + +;; Listas são um tipo muito central, então existe uma grande variedade de +;; funcionalidades para eles, alguns exemplos: +(mapcar #'1+ '(1 2 3)) ; => '(2 3 4) +(mapcar #'+ '(1 2 3) '(10 20 30)) ; => '(11 22 33) +(remove-if-not #'evenp '(1 2 3 4)) ; => '(2 4) +(every #'evenp '(1 2 3 4)) ; => nil +(some #'oddp '(1 2 3 4)) ; => T +(butlast '(subject verb object)) ; => (SUBJECT VERB) + + +;;; Vetores + +;; Vector's literais são arrays de tamanho fixo. +#(1 2 3) ; => #(1 2 3) + +;; Use concatenate para juntar dois vectors +(concatenate 'vector #(1 2 3) #(4 5 6)) ; => #(1 2 3 4 5 6) + +;;; Arrays + +;; Ambos vetores e strings são um caso especial de arrays. + +;; 2D arrays + +(make-array (list 2 2)) + +;; (make-array '(2 2)) também funciona. + +; => #2A((0 0) (0 0)) + +(make-array (list 2 2 2)) + +; => #3A(((0 0) (0 0)) ((0 0) (0 0))) + +;; Cuidado - os valores de inicialição padrões são +;; definidos pela implementção. Aqui vai como defini-lós. + +(make-array '(2) :initial-element 'unset) + +; => #(UNSET UNSET) + +;; E, para acessar o element em 1,1,1 - +(aref (make-array (list 2 2 2)) 1 1 1) + +; => 0 + +;;; Vetores Ajustáveis + +;; Vetores ajustáveis tem a mesma representação impressa que os vectores +;; de tamanho fixo +(defparameter *adjvec* (make-array '(3) :initial-contents '(1 2 3) + :adjustable t :fill-pointer t)) + +*adjvec* ; => #(1 2 3) + +;; Adicionando novo elemento +(vector-push-extend 4 *adjvec*) ; => 3 + +*adjvec* ; => #(1 2 3 4) + + + +;;; Ingenuamente, conjuntos são apenas listas: + +(set-difference '(1 2 3 4) '(4 5 6 7)) ; => (3 2 1) +(intersection '(1 2 3 4) '(4 5 6 7)) ; => 4 +(union '(1 2 3 4) '(4 5 6 7)) ; => (3 2 1 4 5 6 7) +(adjoin 4 '(1 2 3 4)) ; => (1 2 3 4) + +;; Mas você irá querer usar uma estrutura de dados melhor que uma lista encadeada. +;; para performance. + +;;; Dicionários são implementados como hash tables + +;; Cria um hash table +(defparameter *m* (make-hash-table)) + +;; seta um valor +(setf (gethash 'a *m*) 1) + +;; Recupera um valor +(gethash 'a *m*) ; => 1, t + +;; Detalhe - Common Lisp tem multiplos valores de retorno possíveis. gethash +;; retorna t no segundo valor se alguma coisa foi encontrada, e nil se não. + +;; Recuperando um valor não presente retorna nil + (gethash 'd *m*) ;=> nil, nil + +;; Você pode fornecer um valor padrão para uma valores não encontrados +(gethash 'd *m* :not-found) ; => :NOT-FOUND + +;; Vamos tratas múltiplos valores de rotorno aqui. + +(multiple-value-bind + (a b) + (gethash 'd *m*) + (list a b)) +; => (NIL NIL) + +(multiple-value-bind + (a b) + (gethash 'a *m*) + (list a b)) +; => (1 T) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 3. Funções +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Use `lambda' para criar funções anônimas +;; Uma função sempre retorna um valor da última expressão avaliada. +;; A representação exata impressão de uma função varia de acordo ... + +(lambda () "Hello World") ; => # + +;; Use funcall para chamar uma função lambda. +(funcall (lambda () "Hello World")) ; => "Hello World" + +;; Ou Apply +(apply (lambda () "Hello World") nil) ; => "Hello World" + +;; "De-anonymize" a função +(defun hello-world () + "Hello World") +(hello-world) ; => "Hello World" + +;; O () acima é a lista de argumentos da função. +(defun hello (name) + (format nil "Hello, ~a " name)) + +(hello "Steve") ; => "Hello, Steve" + +;; Funções podem ter argumentos opcionais; eles são nil por padrão + +(defun hello (name &optional from) + (if from + (format t "Hello, ~a, from ~a" name from) + (format t "Hello, ~a" name))) + + (hello "Jim" "Alpacas") ;; => Hello, Jim, from Alpacas + +;; E os padrões podem ser configurados... +(defun hello (name &optional (from "The world")) + (format t "Hello, ~a, from ~a" name from)) + +(hello "Steve") +; => Hello, Steve, from The world + +(hello "Steve" "the alpacas") +; => Hello, Steve, from the alpacas + + +;; E é claro, palavras-chaves são permitidas também... frequentemente mais +;; flexivel que &optional. + +(defun generalized-greeter (name &key (from "the world") (honorific "Mx")) + (format t "Hello, ~a ~a, from ~a" honorific name from)) + +(generalized-greeter "Jim") ; => Hello, Mx Jim, from the world + +(generalized-greeter "Jim" :from "the alpacas you met last summer" :honorific "Mr") +; => Hello, Mr Jim, from the alpacas you met last summer + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 4. Igualdade +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Common Lisp tem um sistema sofisticado de igualdade. Alguns são cobertos aqui. + +;; Para número use `=' +(= 3 3.0) ; => t +(= 2 1) ; => nil + +;; para identidade de objeto (aproximadamente) use `eql` +(eql 3 3) ; => t +(eql 3 3.0) ; => nil +(eql (list 3) (list 3)) ; => nil + +;; para listas, strings, e para pedaços de vetores use `equal' +(equal (list 'a 'b) (list 'a 'b)) ; => t +(equal (list 'a 'b) (list 'b 'a)) ; => nil + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 5. Fluxo de Controle +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; Condicionais + +(if t ; testa a expressão + "this is true" ; então expressão + "this is false") ; senão expressão +; => "this is true" + +;; Em condicionais, todos valores não nulos são tratados como true +(member 'Groucho '(Harpo Groucho Zeppo)) ; => '(GROUCHO ZEPPO) +(if (member 'Groucho '(Harpo Groucho Zeppo)) + 'yep + 'nope) +; => 'YEP + +;; `cond' encadeia uma série de testes para selecionar um resultado +(cond ((> 2 2) (error "wrong!")) + ((< 2 2) (error "wrong again!")) + (t 'ok)) ; => 'OK + +;; Typecase é um condicional que escolhe uma de seus cláusulas com base do tipo do valor + +(typecase 1 + (string :string) + (integer :int)) + +; => :int + +;;; Interação + +;; Claro que recursão é suportada: + +(defun walker (n) + (if (zerop n) + :walked + (walker (1- n)))) + +(walker 5) ; => :walked + +;; Na maioria das vezes, nós usamos DOTLISO ou LOOP + +(dolist (i '(1 2 3 4)) + (format t "~a" i)) + +; => 1234 + +(loop for i from 0 below 10 + collect i) + +; => (0 1 2 3 4 5 6 7 8 9) + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 6. Mutação +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Use `setf' para atribuir um novo valor para uma variável existente. Isso foi +;; demonstrado anteriormente no exemplo da hash table. + +(let ((variable 10)) + (setf variable 2)) + ; => 2 + + +;; Um bom estilo Lisp é para minimizar funções destrutivas e para evitar +;; mutação quando razoável. + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 7. Classes e Objetos +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Sem clases Animal, vamos usar os veículos de transporte de tração +;; humana mecânicos. + +(defclass human-powered-conveyance () + ((velocity + :accessor velocity + :initarg :velocity) + (average-efficiency + :accessor average-efficiency + :initarg :average-efficiency)) + (:documentation "A human powered conveyance")) + +;; defcalss, seguido do nome, seguido por uma list de superclass, +;; seguido por um uma 'slot list', seguido por qualidades opcionais como +;; :documentation + +;; Quando nenhuma lista de superclasse é setada, uma lista padrão para +;; para o objeto padrão é usada. Isso *pode* ser mudado, mas não até você +;; saber o que está fazendo. Olhe em Art of the Metaobject Protocol +;; para maiores informações. + +(defclass bicycle (human-powered-conveyance) + ((wheel-size + :accessor wheel-size + :initarg :wheel-size + :documentation "Diameter of the wheel.") + (height + :accessor height + :initarg :height))) + +(defclass recumbent (bicycle) + ((chain-type + :accessor chain-type + :initarg :chain-type))) + +(defclass unicycle (human-powered-conveyance) nil) + +(defclass canoe (human-powered-conveyance) + ((number-of-rowers + :accessor number-of-rowers + :initarg :number-of-rowers))) + + +;; Chamando DESCRIBE na classe human-powered-conveyance no REPL dá: + +(describe 'human-powered-conveyance) + +; COMMON-LISP-USER::HUMAN-POWERED-CONVEYANCE +; [symbol] +; +; HUMAN-POWERED-CONVEYANCE names the standard-class #: +; Documentation: +; A human powered conveyance +; Direct superclasses: STANDARD-OBJECT +; Direct subclasses: UNICYCLE, BICYCLE, CANOE +; Not yet finalized. +; Direct slots: +; VELOCITY +; Readers: VELOCITY +; Writers: (SETF VELOCITY) +; AVERAGE-EFFICIENCY +; Readers: AVERAGE-EFFICIENCY +; Writers: (SETF AVERAGE-EFFICIENCY) + +;; Note o comportamento reflexivo disponível para você! Common Lisp é +;; projetada para ser um sistema interativo. + +;; Para definir um métpdo, vamos encontrar o que nossa cirunferência da +;; roda da bicicleta usando a equação: C = d * pi + +(defmethod circumference ((object bicycle)) + (* pi (wheel-size object))) + +;; pi já é definido para a gente em Lisp! + +;; Vamos supor que nós descobrimos que o valor da eficiência do número +;; de remadores em uma canoa é aproximadamente logarítmica. Isso provavelmente deve ser definido +;; no construtor / inicializador. + +;; Veja como initializar sua instância após Common Lisp ter construído isso: + +(defmethod initialize-instance :after ((object canoe) &rest args) + (setf (average-efficiency object) (log (1+ (number-of-rowers object))))) + +;; Em seguida, para a construção de uma ocorrência e verificar a eficiência média ... + +(average-efficiency (make-instance 'canoe :number-of-rowers 15)) +; => 2.7725887 + + + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 8. Macros +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Macros permitem que você estenda a sintaxe da lingaugem + +;; Common Lisp nãov vem com um loop WHILE- vamos adicionar um. +;; Se obedecermos nossos instintos 'assembler', acabamos com: + +(defmacro while (condition &body body) + "Enquanto `condition` é verdadeiro, `body` é executado. + +`condition` é testado antes de cada execução do `body`" + (let ((block-name (gensym))) + `(tagbody + (unless ,condition + (go ,block-name)) + (progn + ,@body) + ,block-name))) + +;; Vamos dar uma olhada em uma versão alto nível disto: + + +(defmacro while (condition &body body) + "Enquanto `condition` for verdadeira, `body` é executado. + +`condition` é testado antes de cada execução do `body`" + `(loop while ,condition + do + (progn + ,@body))) + +;; Entretanto, com um compilador moderno, isso não é preciso; o LOOP +;; 'form' compila igual e é bem mais fácil de ler. + +;; Noteq ue ``` é usado , bem como `,` e `@`. ``` é um operador 'quote-type' +;; conhecido como 'quasiquote'; isso permite o uso de `,` . `,` permite "unquoting" +;; e variáveis. @ interpolará listas. + +;; Gensym cria um símbolo único garantido que não existe em outras posições +;; o sistema. Isto é porque macros são expandidas em tempo de compilação e +;; variáveis declaradas na macro podem colidir com as variáveis usadas na +;; código regular. + +;; Veja Practical Common Lisp para maiores informações sobre macros. +``` + + +## Leitura Adicional + +[Continua em frente com Practical Common Lisp book.](http://www.gigamonkeys.com/book/) + + +## Créditos + +Muitos agradecimentos ao pessoal de Schema fornecer um grande ponto de partida +o que facilitou muito a migração para Common Lisp. + +- [Paul Khuong](https://github.com/pkhuong) pelas grandes revisiões. -- cgit v1.2.3 From 0b65be8f0c876a10fb2ac823d5c551f90d7ef51e Mon Sep 17 00:00:00 2001 From: elf Date: Fri, 26 Dec 2014 09:06:38 -0200 Subject: Removing comments... --- pt-br/common-lisp-pt.html.markdown | 24 ++++-------------------- 1 file changed, 4 insertions(+), 20 deletions(-) (limited to 'pt-br') diff --git a/pt-br/common-lisp-pt.html.markdown b/pt-br/common-lisp-pt.html.markdown index a2506aec..ba45c4ed 100644 --- a/pt-br/common-lisp-pt.html.markdown +++ b/pt-br/common-lisp-pt.html.markdown @@ -1,27 +1,19 @@ --- - language: "Common Lisp" -filename: commonlisp.lisp +filename: commonlisp-pt.lisp contributors: - ["Paul Nathan", "https://github.com/pnathan"] +translators: + - ["Édipo Luis Féderle", "https://github.com/edipofederle"] --- - - - - ANSI Common Lisp é uma linguagem de uso geral, multi-paradigma, designada para uma variedade de aplicações na indústria. É frequentemente citada como uma linguagem de programação programável. - - O ponto inicial clássico é [Practical Common Lisp and freely available.](http://www.gigamonkeys.com/book/) - - - Outro livro recente e popular é o [Land of Lisp](http://landoflisp.com/). @@ -34,25 +26,17 @@ Outro livro recente e popular é o ;;; "Form" Geral - - ;; Lisp tem dois pedaços fundamentais de sintaxe: o ATOM e S-expression. ;; Tipicamente, S-expressions agrupadas são chamadas de `forms`. - -10 ; um atom; é avaliado para ele mesmo - +10 ; um atom; é avaliado para ele mesmo :THING ;Outro atom; avaliado para o símbolo :thing. - - t ; outro atom, denotado true. - - (+ 1 2 3 4) ; uma s-expression '(4 :foo t) ;outra s-expression -- cgit v1.2.3 From a56473fc318aefbe279077c9fa6efc275894ab39 Mon Sep 17 00:00:00 2001 From: elf Date: Fri, 26 Dec 2014 09:15:03 -0200 Subject: clean up and improvements --- pt-br/common-lisp-pt.html.markdown | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) (limited to 'pt-br') diff --git a/pt-br/common-lisp-pt.html.markdown b/pt-br/common-lisp-pt.html.markdown index ba45c4ed..b154c544 100644 --- a/pt-br/common-lisp-pt.html.markdown +++ b/pt-br/common-lisp-pt.html.markdown @@ -12,7 +12,7 @@ para uma variedade de aplicações na indústria. É frequentemente citada como uma linguagem de programação programável. -O ponto inicial clássico é [Practical Common Lisp and freely available.](http://www.gigamonkeys.com/book/) +O ponto inicial clássico é [Practical Common Lisp e livremente disponível](http://www.gigamonkeys.com/book/) Outro livro recente e popular é o [Land of Lisp](http://landoflisp.com/). @@ -60,7 +60,7 @@ t ; outro atom, denotado true. ;; Existe uma variedade de implementações; a maioria segue o padrão. ;; CLISP é um bom ponto de partida. -;; Bibliotecas são gerenciadas através do Quicklisp.org's Quicklisp systemm. +;; Bibliotecas são gerenciadas através do Quicklisp.org's Quicklisp sistema. ;; Common Lisp é normalmente desenvolvido com um editor de texto e um REPL ;; (Read Evaluate Print Loop) rodando ao mesmo tempo. O REPL permite exploração @@ -73,7 +73,7 @@ t ; outro atom, denotado true. ;;; Símbolos -'foo ; => FOO Perceba que um símbolo é automáticamente convertido para maíusculo. +'foo ; => FOO Perceba que um símbolo é automáticamente convertido para maiúscula. ;; Intern manualmente cria um símbolo a partir de uma string. @@ -413,7 +413,8 @@ nil ; para false - e para lista vazia ((< 2 2) (error "wrong again!")) (t 'ok)) ; => 'OK -;; Typecase é um condicional que escolhe uma de seus cláusulas com base do tipo do valor +;; Typecase é um condicional que escolhe uma de seus cláusulas com base do tipo +;; do seu valor (typecase 1 (string :string) @@ -542,8 +543,8 @@ nil ; para false - e para lista vazia ;; pi já é definido para a gente em Lisp! ;; Vamos supor que nós descobrimos que o valor da eficiência do número -;; de remadores em uma canoa é aproximadamente logarítmica. Isso provavelmente deve ser definido -;; no construtor / inicializador. +;; de remadores em uma canoa é aproximadamente logarítmica. Isso provavelmente +;; deve ser definido no construtor / inicializador. ;; Veja como initializar sua instância após Common Lisp ter construído isso: @@ -564,7 +565,7 @@ nil ; para false - e para lista vazia ;; Macros permitem que você estenda a sintaxe da lingaugem -;; Common Lisp nãov vem com um loop WHILE- vamos adicionar um. +;; Common Lisp não vem com um loop WHILE - vamos adicionar um. ;; Se obedecermos nossos instintos 'assembler', acabamos com: (defmacro while (condition &body body) -- cgit v1.2.3 From f4c735c05021418bf8e207d49619397bfe37eff7 Mon Sep 17 00:00:00 2001 From: elf Date: Fri, 26 Dec 2014 09:19:21 -0200 Subject: fix. --- pt-br/common-lisp-pt.html.markdown | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'pt-br') diff --git a/pt-br/common-lisp-pt.html.markdown b/pt-br/common-lisp-pt.html.markdown index b154c544..5561c23d 100644 --- a/pt-br/common-lisp-pt.html.markdown +++ b/pt-br/common-lisp-pt.html.markdown @@ -178,7 +178,7 @@ nil ; para false - e para lista vazia (dog-p *rover*) ; => t ;; ewww) (dog-name *rover*) ; => "rover" -;; Dog-p, make-dog, and dog-name foram todas criadas por defstruct! +;; Dog-p, make-dog, e dog-name foram todas criadas por defstruct! ;;; Pares ;; `cons' constroi pares, `car' and `cdr' extrai o primeiro @@ -615,7 +615,7 @@ nil ; para false - e para lista vazia ## Créditos -Muitos agradecimentos ao pessoal de Schema fornecer um grande ponto de partida +Muitos agradecimentos ao pessoal de Schema por fornecer um grande ponto de partida o que facilitou muito a migração para Common Lisp. - [Paul Khuong](https://github.com/pkhuong) pelas grandes revisiões. -- cgit v1.2.3 From b59262601656a0f803729d37b6c83d414af0457a Mon Sep 17 00:00:00 2001 From: elf Date: Fri, 26 Dec 2014 09:20:30 -0200 Subject: fix word --- pt-br/common-lisp-pt.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'pt-br') diff --git a/pt-br/common-lisp-pt.html.markdown b/pt-br/common-lisp-pt.html.markdown index 5561c23d..ce654846 100644 --- a/pt-br/common-lisp-pt.html.markdown +++ b/pt-br/common-lisp-pt.html.markdown @@ -618,4 +618,4 @@ nil ; para false - e para lista vazia Muitos agradecimentos ao pessoal de Schema por fornecer um grande ponto de partida o que facilitou muito a migração para Common Lisp. -- [Paul Khuong](https://github.com/pkhuong) pelas grandes revisiões. +- [Paul Khuong](https://github.com/pkhuong) pelas grandes revisões. -- cgit v1.2.3 From aa13db251bec274a1227235f0cea376c100f003b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Ara=C3=BAjo?= Date: Wed, 7 Jan 2015 14:35:03 -0300 Subject: [XML/en] translated to [XML/pt-br] --- pt-br/xml-pt.html.markdown | 133 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 133 insertions(+) create mode 100644 pt-br/xml-pt.html.markdown (limited to 'pt-br') diff --git a/pt-br/xml-pt.html.markdown b/pt-br/xml-pt.html.markdown new file mode 100644 index 00000000..40ddbc3a --- /dev/null +++ b/pt-br/xml-pt.html.markdown @@ -0,0 +1,133 @@ +--- +language: xml +filename: learnxml.xml +contributors: + - ["João Farias", "https://github.com/JoaoGFarias"] +translators: + - ["Miguel Araújo", "https://github.com/miguelarauj1o"] +lang: pt-br +--- + +XML é uma linguagem de marcação projetada para armazenar e transportar dados. + +Ao contrário de HTML, XML não especifica como exibir ou formatar os dados, +basta carregá-lo. + +* Sintaxe XML + +```xml + + + + + + Everyday Italian + Giada De Laurentiis + 2005 + 30.00 + + + Harry Potter + J K. Rowling + 2005 + 29.99 + + + Learning XML + Erik T. Ray + 2003 + 39.95 + + + + + + + + + + +computer.gif + + +``` + +* Documento bem formatado x Validação + +Um documento XML é bem formatado se estiver sintaticamente correto.No entanto, +é possível injetar mais restrições no documento, utilizando definições de +documentos, tais como DTD e XML Schema. + +Um documento XML que segue uma definição de documento é chamado válido, sobre +esse documento. + +Com esta ferramenta, você pode verificar os dados XML fora da lógica da aplicação. + +```xml + + + + + + + + Everyday Italian + 30.00 + + + + + + + + + + +]> + + + + + + + + + + + + + +]> + + + + Everyday Italian + 30.00 + + +``` \ No newline at end of file -- cgit v1.2.3 From 7dad0b92cc81b34c98bdcb204ada59c4fd1f627b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Ara=C3=BAjo?= Date: Thu, 8 Jan 2015 11:28:11 -0300 Subject: [Hy/en] translated to [Hy/pt-bt] --- pt-br/hy-pt.html.markdown | 176 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 176 insertions(+) create mode 100644 pt-br/hy-pt.html.markdown (limited to 'pt-br') diff --git a/pt-br/hy-pt.html.markdown b/pt-br/hy-pt.html.markdown new file mode 100644 index 00000000..4230579d --- /dev/null +++ b/pt-br/hy-pt.html.markdown @@ -0,0 +1,176 @@ +--- +language: hy +filename: learnhy.hy +contributors: + - ["Abhishek L", "http://twitter.com/abhishekl"] +translators: + - ["Miguel Araújo", "https://github.com/miguelarauj1o"] +lang: pt-br +--- + +Hy é um dialeto de Lisp escrito sobre Python. Isto é possível convertendo +código Hy em árvore sintática abstrata python (ast). Portanto, isto permite +hy chamar código python nativo e vice-versa. + +Este tutorial funciona para hy ≥ 0.9.12 + +```clojure +;; Isso dá uma introdução básica em hy, como uma preliminar para o link abaixo +;; http://try-hy.appspot.com +;; +; Comentários em ponto-e-vírgula, como em outros LISPS + +;; s-noções básicas de expressão +; programas Lisp são feitos de expressões simbólicas ou sexps que se assemelham +(some-function args) +; agora o essencial "Olá mundo" +(print "hello world") + +;; Tipos de dados simples +; Todos os tipos de dados simples são exatamente semelhantes aos seus homólogos +; em python que +42 ; => 42 +3.14 ; => 3.14 +True ; => True +4+10j ; => (4+10j) um número complexo + +; Vamos começar com um pouco de aritmética muito simples +(+ 4 1) ;=> 5 +; o operador é aplicado a todos os argumentos, como outros lisps +(+ 4 1 2 3) ;=> 10 +(- 2 1) ;=> 1 +(* 4 2) ;=> 8 +(/ 4 1) ;=> 4 +(% 4 2) ;=> 0 o operador módulo +; exponenciação é representado pelo operador ** como python +(** 3 2) ;=> 9 +; formas aninhadas vão fazer a coisa esperada +(+ 2 (* 4 2)) ;=> 10 +; também operadores lógicos e ou não e igual etc. faz como esperado +(= 5 4) ;=> False +(not (= 5 4)) ;=> True + +;; variáveis +; variáveis são definidas usando SETV, nomes de variáveis podem usar utf-8, exceto +; for ()[]{}",'`;#| +(setv a 42) +(setv π 3.14159) +(def *foo* 42) +;; outros tipos de dados de armazenamento +; strings, lists, tuples & dicts +; estes são exatamente os mesmos tipos de armazenamento de python +"hello world" ;=> "hello world" +; operações de string funcionam semelhante em python +(+ "hello " "world") ;=> "hello world" +; Listas são criadas usando [], a indexação começa em 0 +(setv mylist [1 2 3 4]) +; tuplas são estruturas de dados imutáveis +(setv mytuple (, 1 2)) +; dicionários são pares de valores-chave +(setv dict1 {"key1" 42 "key2" 21}) +; :nome pode ser utilizado para definir palavras-chave em hy que podem ser utilizados para as chaves +(setv dict2 {:key1 41 :key2 20}) +; usar 'get' para obter o elemento em um índice/key +(get mylist 1) ;=> 2 +(get dict1 "key1") ;=> 42 +; Alternativamente, se foram utilizadas palavras-chave que podem ser chamadas diretamente +(:key1 dict2) ;=> 41 + +;; funções e outras estruturas de programa +; funções são definidas usando defn, o último sexp é devolvido por padrão +(defn greet [name] + "A simple greeting" ; uma docstring opcional + (print "hello " name)) + +(greet "bilbo") ;=> "hello bilbo" + +; funções podem ter argumentos opcionais, bem como argumentos-chave +(defn foolists [arg1 &optional [arg2 2]] + [arg1 arg2]) + +(foolists 3) ;=> [3 2] +(foolists 10 3) ;=> [10 3] + +; funções anônimas são criados usando construtores 'fn' ou 'lambda' +; que são semelhantes para 'defn' +(map (fn [x] (* x x)) [1 2 3 4]) ;=> [1 4 9 16] + +;; operações de sequência +; hy tem algumas utils embutidas para operações de sequência, etc. +; recuperar o primeiro elemento usando 'first' ou 'car' +(setv mylist [1 2 3 4]) +(setv mydict {"a" 1 "b" 2}) +(first mylist) ;=> 1 + +; corte listas usando 'slice' +(slice mylist 1 3) ;=> [2 3] + +; obter elementos de uma lista ou dict usando 'get' +(get mylist 1) ;=> 2 +(get mydict "b") ;=> 2 +; lista de indexação começa a partir de 0, igual em python +; assoc pode definir elementos em chaves/índices +(assoc mylist 2 10) ; faz mylist [1 2 10 4] +(assoc mydict "c" 3) ; faz mydict {"a" 1 "b" 2 "c" 3} +; há toda uma série de outras funções essenciais que torna o trabalho com +; sequências uma diversão + +;; Python interop +;; importação funciona exatamente como em python +(import datetime) +(import [functools [partial reduce]]) ; importa fun1 e fun2 do module1 +(import [matplotlib.pyplot :as plt]) ; fazendo uma importação em foo como em bar +; todos os métodos de python embutidas etc. são acessíveis a partir hy +; a.foo(arg) is called as (.foo a arg) +(.split (.strip "hello world ")) ;=> ["hello" "world"] + +;; Condicionais +; (if condition (body-if-true) (body-if-false) +(if (= passcode "moria") + (print "welcome") + (print "Speak friend, and Enter!")) + +; aninhe múltiplas cláusulas 'if else if' com cond +(cond + [(= someval 42) + (print "Life, universe and everything else!")] + [(> someval 42) + (print "val too large")] + [(< someval 42) + (print "val too small")]) + +; declarações de grupo com 'do', essas são executadas sequencialmente +; formas como defn tem um 'do' implícito +(do + (setv someval 10) + (print "someval is set to " someval)) ;=> 10 + +; criar ligações lexicais com 'let', todas as variáveis definidas desta forma +; tem escopo local +(let [[nemesis {"superman" "lex luther" + "sherlock" "moriarty" + "seinfeld" "newman"}]] + (for [(, h v) (.items nemesis)] + (print (.format "{0}'s nemesis was {1}" h v)))) + +;; classes +; classes são definidas da seguinte maneira +(defclass Wizard [object] + [[--init-- (fn [self spell] + (setv self.spell spell) ; init a mágica attr + None)] + [get-spell (fn [self] + self.spell)]]) + +;; acesse hylang.org +``` + +### Outras Leituras + +Este tutorial é apenas uma introdução básica para hy/lisp/python. + +Docs Hy: [http://hy.readthedocs.org](http://hy.readthedocs.org) + +Repo Hy no Github: [http://github.com/hylang/hy](http://github.com/hylang/hy) + +Acesso ao freenode irc com #hy, hashtag no twitter: #hylang -- cgit v1.2.3 From dd5588a2194b4e1f98fc4cee8a2fc277f6eae2f9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Ara=C3=BAjo?= Date: Tue, 13 Jan 2015 10:26:08 -0300 Subject: [C++/en] translated to [C++/pt-br] --- pt-br/c++-pt.html.markdown | 591 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 591 insertions(+) create mode 100644 pt-br/c++-pt.html.markdown (limited to 'pt-br') diff --git a/pt-br/c++-pt.html.markdown b/pt-br/c++-pt.html.markdown new file mode 100644 index 00000000..243627cb --- /dev/null +++ b/pt-br/c++-pt.html.markdown @@ -0,0 +1,591 @@ +--- +language: c++ +filename: learncpp.cpp +contributors: + - ["Steven Basart", "http://github.com/xksteven"] + - ["Matt Kline", "https://github.com/mrkline"] +translators: + - ["Miguel Araújo", "https://github.com/miguelarauj1o"] +lang: pt-br +--- + +C++ é uma linguagem de programação de sistemas que, +C++ is a systems programming language that, +[de acordo com seu inventor Bjarne Stroustrup](http://channel9.msdn.com/Events/Lang-NEXT/Lang-NEXT-2014/Keynote), +foi concebida para + +- ser um "C melhor" +- suportar abstração de dados +- suportar programação orientada a objetos +- suportar programação genérica + +Embora sua sintaxe pode ser mais difícil ou complexa do que as linguagens mais +recentes, C++ é amplamente utilizado porque compila para instruções nativas que +podem ser executadas diretamente pelo processador e oferece um controlo rígido sobre hardware (como C), enquanto oferece recursos de alto nível, como os +genéricos, exceções e classes. Esta combinação de velocidade e funcionalidade +faz C++ uma das linguagens de programação mais utilizadas. + +```c++ +////////////////// +// Comparação com C +////////////////// + +// C ++ é quase um super conjunto de C e compartilha sua sintaxe básica para +// declarações de variáveis, tipos primitivos, e funções. No entanto, C++ varia +// em algumas das seguintes maneiras: + +// A função main() em C++ deve retornar um int, embora void main() é aceita +// pela maioria dos compiladores (gcc, bumbum, etc.) +// Este valor serve como o status de saída do programa. +// Veja http://en.wikipedia.org/wiki/Exit_status para mais informações. + +int main(int argc, char** argv) +{ + // Argumentos de linha de comando são passados em pelo argc e argv da mesma + // forma que eles estão em C. + // argc indica o número de argumentos, + // e argv é um array de strings, feito C (char*) representado os argumentos + // O primeiro argumento é o nome pelo qual o programa foi chamado. + // argc e argv pode ser omitido se você não se importa com argumentos, + // dando a assinatura da função de int main() + + // Uma saída de status de 0 indica sucesso. + return 0; +} + +// Em C++, caracteres literais são um byte. +sizeof('c') == 1 + +// Em C, caracteres literais são do mesmo tamanho que ints. +sizeof('c') == sizeof(10) + +// C++ tem prototipagem estrita +void func(); // função que não aceita argumentos + +// Em C +void func(); // função que pode aceitar qualquer número de argumentos + +// Use nullptr em vez de NULL em C++ +int* ip = nullptr; + +// Cabeçalhos padrão C estão disponíveis em C++, +// mas são prefixados com "c" e não têm sufixo .h + +#include + +int main() +{ + printf("Hello, world!\n"); + return 0; +} + +/////////////////////// +// Sobrecarga de função +/////////////////////// + +// C++ suporta sobrecarga de função +// desde que cada função tenha parâmetros diferentes. + +void print(char const* myString) +{ + printf("String %s\n", myString); +} + +void print(int myInt) +{ + printf("My int is %d", myInt); +} + +int main() +{ + print("Hello"); // Funciona para void print(const char*) + print(15); // Funciona para void print(int) +} + +///////////////////////////// +// Parâmetros padrão de função +///////////////////////////// + +// Você pode fornecer argumentos padrões para uma função se eles não são +// fornecidos pelo chamador. + +void doSomethingWithInts(int a = 1, int b = 4) +{ + // Faça alguma coisa com os ints aqui +} + +int main() +{ + doSomethingWithInts(); // a = 1, b = 4 + doSomethingWithInts(20); // a = 20, b = 4 + doSomethingWithInts(20, 5); // a = 20, b = 5 +} + +// Argumentos padrões devem estar no final da lista de argumentos. + +void invalidDeclaration(int a = 1, int b) // Erro! +{ +} + + +///////////// +// Namespaces (nome de espaços) +///////////// + +// Namespaces fornecem escopos distintos para variável, função e outras +// declarações. Namespaces podem estar aninhados. + +namespace First { + namespace Nested { + void foo() + { + printf("This is First::Nested::foo\n"); + } + } // Fim do namespace aninhado +} // Fim do namespace First + +namespace Second { + void foo() + { + printf("This is Second::foo\n") + } +} + +void foo() +{ + printf("This is global foo\n"); +} + +int main() +{ + // Assuma que tudo é do namespace "Second" a menos que especificado de + // outra forma. + using namespace Second; + + foo(); // imprime "This is Second::foo" + First::Nested::foo(); // imprime "This is First::Nested::foo" + ::foo(); // imprime "This is global foo" +} + +/////////////// +// Entrada/Saída +/////////////// + +// C ++ usa a entrada e saída de fluxos (streams) +// cin, cout, and cerr representa stdin, stdout, and stderr. +// << É o operador de inserção e >> é o operador de extração. + +#include // Inclusão para o I/O streams + +using namespace std; // Streams estão no namespace std (biblioteca padrão) + +int main() +{ + int myInt; + + // Imprime na saída padrão (ou terminal/tela) + cout << "Enter your favorite number:\n"; + // Pega a entrada + cin >> myInt; + + // cout também pode ser formatado + cout << "Your favorite number is " << myInt << "\n"; + // imprime "Your favorite number is " + + cerr << "Usado para mensagens de erro"; +} + +////////// +// Strings +////////// + +// Strings em C++ são objetos e têm muitas funções de membro +#include + +using namespace std; // Strings também estão no namespace std (bib. padrão) + +string myString = "Hello"; +string myOtherString = " World"; + +// + é usado para concatenação. +cout << myString + myOtherString; // "Hello World" + +cout << myString + " You"; // "Hello You" + +// Em C++, strings são mutáveis e têm valores semânticos. +myString.append(" Dog"); +cout << myString; // "Hello Dog" + + +///////////// +// Referência +///////////// + +// Além de indicadores como os de C, C++ têm _referências_. Esses são tipos de +// ponteiro que não pode ser reatribuída uma vez definidos e não pode ser nulo. +// Eles também têm a mesma sintaxe que a própria variável: Não * é necessário +// para _dereferencing_ e & (endereço de) não é usado para atribuição. + +using namespace std; + +string foo = "I am foo"; +string bar = "I am bar"; + + +string& fooRef = foo; // Isso cria uma referência para foo. +fooRef += ". Hi!"; // Modifica foo através da referência +cout << fooRef; // Imprime "I am foo. Hi!" + +// Não realocar "fooRef". Este é o mesmo que "foo = bar", e foo == "I am bar" +// depois desta linha. + +fooRef = bar; + +const string& barRef = bar; // Cria uma referência const para bar. +// Como C, valores const (e ponteiros e referências) não podem ser modificado. +barRef += ". Hi!"; // Erro, referência const não pode ser modificada. + +////////////////////////////////////////// +// Classes e programação orientada a objeto +////////////////////////////////////////// + +// Primeiro exemplo de classes +#include + +// Declara a classe. +// As classes são geralmente declarado no cabeçalho arquivos (.h ou .hpp). +class Dog { + // Variáveis de membro e funções são privadas por padrão. + std::string name; + int weight; + +// Todos os membros a seguir este são públicos até que "private:" ou +// "protected:" é encontrado. +public: + + // Construtor padrão + Dog(); + + // Declarações de função Membro (implementações a seguir) + // Note que usamos std :: string aqui em vez de colocar + // using namespace std; + // acima. + // Nunca coloque uma declaração "using namespace" em um cabeçalho. + void setName(const std::string& dogsName); + + void setWeight(int dogsWeight); + + // Funções que não modificam o estado do objecto devem ser marcadas como + // const. Isso permite que você chamá-los se for dada uma referência const + // para o objeto. Além disso, observe as funções devem ser explicitamente + // declarados como _virtual_, a fim de ser substituídas em classes + // derivadas. As funções não são virtuais por padrão por razões de + // performance. + + virtual void print() const; + + // As funções também podem ser definidas no interior do corpo da classe. + // Funções definidas como tal são automaticamente embutidas. + void bark() const { std::cout << name << " barks!\n" } + + // Junto com os construtores, C++ fornece destruidores. + // Estes são chamados quando um objeto é excluído ou fica fora do escopo. + // Isto permite paradigmas poderosos, como RAII + // (veja abaixo) + // Destruidores devem ser virtual para permitir que as classes de ser + // derivada desta. + virtual ~Dog(); + +}; // Um ponto e vírgula deve seguir a definição de classe. + +// Funções membro da classe geralmente são implementados em arquivos .cpp. +void Dog::Dog() +{ + std::cout << "A dog has been constructed\n"; +} + +// Objetos (como strings) devem ser passados por referência +// se você está modificando-os ou referência const se você não é. +void Dog::setName(const std::string& dogsName) +{ + name = dogsName; +} + +void Dog::setWeight(int dogsWeight) +{ + weight = dogsWeight; +} + +// Observe que "virtual" só é necessária na declaração, não a definição. +void Dog::print() const +{ + std::cout << "Dog is " << name << " and weighs " << weight << "kg\n"; +} + +void Dog::~Dog() +{ + cout << "Goodbye " << name << "\n"; +} + +int main() { + Dog myDog; // imprime "A dog has been constructed" + myDog.setName("Barkley"); + myDog.setWeight(10); + myDog.printDog(); // imprime "Dog is Barkley and weighs 10 kg" + return 0; +} // imprime "Goodbye Barkley" + +// herança: + +// Essa classe herda tudo público e protegido da classe Dog +class OwnedDog : public Dog { + + void setOwner(const std::string& dogsOwner) + + // Substituir o comportamento da função de impressão de todas OwnedDogs. + // Ver http://en.wikipedia.org/wiki/Polymorphism_(computer_science)#Subtyping + // Para uma introdução mais geral, se você não estiver familiarizado com o + // polimorfismo subtipo. A palavra-chave override é opcional, mas torna-se + // na verdade você está substituindo o método em uma classe base. + void print() const override; + +private: + std::string owner; +}; + +// Enquanto isso, no arquivo .cpp correspondente: + +void OwnedDog::setOwner(const std::string& dogsOwner) +{ + owner = dogsOwner; +} + +void OwnedDog::print() const +{ + Dog::print(); // Chame a função de impressão na classe Dog base de + std::cout << "Dog is owned by " << owner << "\n"; + // Prints "Dog is and weights " + // "Dog is owned by " +} + +////////////////////////////////////////// +// Inicialização e Sobrecarga de Operadores +////////////////////////////////////////// + +// Em C ++, você pode sobrecarregar o comportamento dos operadores, tais como +// +, -, *, /, etc. Isto é feito através da definição de uma função que é +// chamado sempre que o operador é usado. + +#include +using namespace std; + +class Point { +public: + // Variáveis membro pode ser dado valores padrão desta maneira. + double x = 0; + double y = 0; + + // Define um construtor padrão que não faz nada + // mas inicializar o Point para o valor padrão (0, 0) + Point() { }; + + // A sintaxe a seguir é conhecido como uma lista de inicialização + // e é a maneira correta de inicializar os valores de membro de classe + Point (double a, double b) : + x(a), + y(b) + { /* Não fazer nada, exceto inicializar os valores */ } + + // Sobrecarrega o operador +. + Point operator+(const Point& rhs) const; + + // Sobrecarregar o operador +=. + Point& operator+=(const Point& rhs); + + // Ele também faria sentido para adicionar os operadores - e -=, + // mas vamos pular para sermos breves. +}; + +Point Point::operator+(const Point& rhs) const +{ + // Criar um novo ponto que é a soma de um e rhs. + return Point(x + rhs.x, y + rhs.y); +} + +Point& Point::operator+=(const Point& rhs) +{ + x += rhs.x; + y += rhs.y; + return *this; +} + +int main () { + Point up (0,1); + Point right (1,0); + // Isto chama que o operador ponto + + // Ressalte-se a chamadas (função)+ com direito como seu parâmetro... + Point result = up + right; + // Imprime "Result is upright (1,1)" + cout << "Result is upright (" << result.x << ',' << result.y << ")\n"; + return 0; +} + +///////////////////////// +// Tratamento de Exceções +///////////////////////// + +// A biblioteca padrão fornece alguns tipos de exceção +// (see http://en.cppreference.com/w/cpp/error/exception) +// mas qualquer tipo pode ser jogado como uma exceção +#include + +// Todas as exceções lançadas dentro do bloco try pode ser capturado por +// manipuladores de captura subseqüentes +try { + // Não aloca exceções no heap usando _new_. + throw std::exception("A problem occurred"); +} +// Capturar exceções por referência const se eles são objetos +catch (const std::exception& ex) +{ + std::cout << ex.what(); +// Captura qualquer exceção não capturada pelos blocos _catch_ anteriores +} catch (...) +{ + std::cout << "Exceção desconhecida encontrada"; + throw; // Re-lança a exceção +} + +/////// +// RAII +/////// + +// RAII significa alocação de recursos é de inicialização. +// Muitas vezes, é considerado o paradigma mais poderoso em C++, e é o +// conceito simples que um construtor para um objeto adquire recursos daquele +// objeto e o destruidor liberá-los. + +// Para entender como isso é útil, +// Considere uma função que usa um identificador de arquivo C: +void doSomethingWithAFile(const char* filename) +{ + // Para começar, assuma que nada pode falhar. + + FILE* fh = fopen(filename, "r"); // Abra o arquivo em modo de leitura. + + doSomethingWithTheFile(fh); + doSomethingElseWithIt(fh); + + fclose(fh); // Feche o arquivo. +} + +// Infelizmente, as coisas são levemente complicadas para tratamento de erros. +// Suponha que fopen pode falhar, e que doSomethingWithTheFile e +// doSomethingElseWithIt retornam códigos de erro se eles falharem. (As +// exceções são a forma preferida de lidar com o fracasso, mas alguns +// programadores, especialmente aqueles com um conhecimento em C, discordam +// sobre a utilidade de exceções). Agora temos que verificar cada chamada para +// o fracasso e fechar o identificador de arquivo se ocorreu um problema. + +bool doSomethingWithAFile(const char* filename) +{ + FILE* fh = fopen(filename, "r"); // Abra o arquivo em modo de leitura + if (fh == nullptr) // O ponteiro retornado é nulo em caso de falha. + reuturn false; // Relate o fracasso para o chamador. + + // Suponha cada função retorne false, se falhar + if (!doSomethingWithTheFile(fh)) { + fclose(fh); // Feche o identificador de arquivo para que ele não vaze. + return false; // Propague o erro. + } + if (!doSomethingElseWithIt(fh)) { + fclose(fh); // Feche o identificador de arquivo para que ele não vaze. + return false; // Propague o erro. + } + + fclose(fh); // Feche o identificador de arquivo para que ele não vaze. + return true; // Indica sucesso +} + +// Programadores C frequentemente limpam isso um pouco usando Goto: +bool doSomethingWithAFile(const char* filename) +{ + FILE* fh = fopen(filename, "r"); + if (fh == nullptr) + reuturn false; + + if (!doSomethingWithTheFile(fh)) + goto failure; + + if (!doSomethingElseWithIt(fh)) + goto failure; + + fclose(fh); // Close the file + return true; // Indica sucesso + +failure: + fclose(fh); + return false; // Propague o erro. +} + +// Se as funções indicam erros usando exceções, +// as coisas são um pouco mais limpo, mas ainda abaixo do ideal. +void doSomethingWithAFile(const char* filename) +{ + FILE* fh = fopen(filename, "r"); // Abra o arquivo em modo de leitura. + if (fh == nullptr) + throw std::exception("Não pode abrir o arquivo."); + + try { + doSomethingWithTheFile(fh); + doSomethingElseWithIt(fh); + } + catch (...) { + fclose(fh); // Certifique-se de fechar o arquivo se ocorrer um erro. + throw; // Em seguida, re-lance a exceção. + } + + fclose(fh); // Feche o arquivo + // Tudo ocorreu com sucesso! +} + +// Compare isso com o uso de C++ classe fluxo de arquivo (fstream) fstream usa +// seu destruidor para fechar o arquivo. Lembre-se de cima que destruidores são +// automaticamente chamado sempre que um objeto cai fora do âmbito. +void doSomethingWithAFile(const std::string& filename) +{ + // ifstream é curto para o fluxo de arquivo de entrada + std::ifstream fh(filename); // Abra o arquivo + + // faça alguma coisa com o arquivo + doSomethingWithTheFile(fh); + doSomethingElseWithIt(fh); + +} // O arquivo é automaticamente fechado aqui pelo destructor + +// Isto tem _grandes_ vantagens: +// 1. Não importa o que aconteça, +// o recurso (neste caso, o identificador de ficheiro) irá ser limpo. +// Depois de escrever o destruidor corretamente, +// É _impossível_ esquecer de fechar e vazar o recurso +// 2. Nota-se que o código é muito mais limpo. +// As alças destructor fecham o arquivo por trás das cenas +// sem que você precise se preocupar com isso. +// 3. O código é seguro de exceção. +// Uma exceção pode ser jogado em qualquer lugar na função e a limpeza +// irá ainda ocorrer. + +// Todos códigos C++ usam RAII extensivamente para todos os recursos. +// Outros exemplos incluem +// - Memória usa unique_ptr e shared_ptr +// - Contentores - a lista da biblioteca ligada padrão, +// vetor (i.e. array de autodimensionamento), mapas hash, e assim por diante +// tudo é automaticamente destruído quando eles saem de escopo +// - Mutex usa lock_guard e unique_lock +``` +Leitura Adicional: + +Uma referência atualizada da linguagem pode ser encontrada em + + +Uma fonte adicional pode ser encontrada em \ No newline at end of file -- cgit v1.2.3 From dff86ae3cb5618609f8238cca20c2493b5ffc240 Mon Sep 17 00:00:00 2001 From: Adam Bard Date: Tue, 13 Jan 2015 20:09:14 +0000 Subject: Update common-lisp-pt.html.markdown --- pt-br/common-lisp-pt.html.markdown | 1 + 1 file changed, 1 insertion(+) (limited to 'pt-br') diff --git a/pt-br/common-lisp-pt.html.markdown b/pt-br/common-lisp-pt.html.markdown index ce654846..03a7c15c 100644 --- a/pt-br/common-lisp-pt.html.markdown +++ b/pt-br/common-lisp-pt.html.markdown @@ -5,6 +5,7 @@ contributors: - ["Paul Nathan", "https://github.com/pnathan"] translators: - ["Édipo Luis Féderle", "https://github.com/edipofederle"] +lang: pt-br --- ANSI Common Lisp é uma linguagem de uso geral, multi-paradigma, designada -- cgit v1.2.3 From 9f765b9c7b0b207b51b914161313fdb7ecadaa5c Mon Sep 17 00:00:00 2001 From: Suzane Sant Ana Date: Sat, 17 Jan 2015 09:17:39 -0200 Subject: removing a piece in english in pt-br translation --- pt-br/c++-pt.html.markdown | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) (limited to 'pt-br') diff --git a/pt-br/c++-pt.html.markdown b/pt-br/c++-pt.html.markdown index 243627cb..61625ebe 100644 --- a/pt-br/c++-pt.html.markdown +++ b/pt-br/c++-pt.html.markdown @@ -9,8 +9,7 @@ translators: lang: pt-br --- -C++ é uma linguagem de programação de sistemas que, -C++ is a systems programming language that, +C++ é uma linguagem de programação de sistemas que, [de acordo com seu inventor Bjarne Stroustrup](http://channel9.msdn.com/Events/Lang-NEXT/Lang-NEXT-2014/Keynote), foi concebida para @@ -588,4 +587,4 @@ Leitura Adicional: Uma referência atualizada da linguagem pode ser encontrada em -Uma fonte adicional pode ser encontrada em \ No newline at end of file +Uma fonte adicional pode ser encontrada em -- cgit v1.2.3