Buscar
Minha Conta

Atendimento(21) 2262-3111 / (21) 2262-3111

Primeiros passos com a linguagem Rust

Descrição do livro Este livro apresenta a linguagem Rust de forma básica e introdutória para leitores e estudantes de programação que não têm conhecimentos prévios da linguagem.

VITRINE Os TOP de vendas !!

+-

Quem viu este produto , comprou

Quem viu este produto , também se interessou

  • Descrição
    Primeiros passos com a linguagem Rust

    Este livro apresenta a linguagem Rust de forma básica e introdutória para leitores e estudantes de programação que não têm conhecimentos prévios da linguagem.

    Assuntos abordados neste livro:

    tipos de dados;
    variáveis mutáveis e imutáveis;
    constantes;
    operadores aritméticos;
    expressões aritméticas;
    operações de entrada e saída;
    condições;
    decisões;
    operadores relacionais e lógicos;
    desvios condicionais;
    ações de divisibilidade;
    validação do fluxo de entrada de dados;
    laços;
    sub-rotinas como funções e procedimentos;
    passagem de parâmetro;
    estruturas de dados matriciais estáticas e dinâmicas;
    conversão de tipos de dados;
    ponteiros;
    biblioteca definida pelo programador;
    noções de programação genérica e funcional;
    tratamento de erros e exceções;
    aplicação de criptografia, além de outros pequenos recursos operacionais.
  • Sobre o Autor
  • Especificação

    Características

    Tipo de LivroLivro Físico

    Especificações

    Sobre o AutorJosé Augusto N. G. Manzano

    José Augusto Navarro Garcia Manzano nascido em São Paulo/SP, em 26 de abril de 1965. Possui formação acadêmica em Análise e Desenvolvimento de Sistemas e Ciências Econômicas, além de Licenciatura em Matemática. Atua na área de Tecnologia da Informação, Computação e Informática desde 1986. É professor no Instituto Federal de Educação, Ciência e Tecnologia de São Paulo (IFSP), antiga Escola Técnica Federal.
    Informações TécnicasSumário
    Agradecimentos........................................................................................................................9
    Prefácio ..................................................................................................................................10
    Sobre o autor ..........................................................................................................................12

    Capítulo 1 ¦ Linguagem Rust...................................................................................................13
    1.1 Breve histórico da linguagem Rust............................................................................... 13
    1.2 Instalação e teste da linguagem Rust............................................................................ 15
    1.3 Gerenciador cargo....................................................................................................... 18
    1.4 Notação utilizada........................................................................................................ 20
    1.5 Gerenciamento de memória......................................................................................... 21

    Capítulo 2 ¦ Ação sequencial....................................................................................................22
    2.1 Tipos de dados............................................................................................................22
    2.1.1 Inteiros................................................................................................................23
    2.1.2 Reais................................................................................................................... 24
    2.1.3 Cadeias e caracteres.............................................................................................25
    2.1.4 Lógicos................................................................................................................ 26
    2.2 Variáveis..................................................................................................................... 26
    2.3 Constantes ................................................................................................................. 29
    2.4 Operadores aritméticos...............................................................................................30
    2.5 Expressões aritméticas................................................................................................ 32
    2.6 Instruções da linguagem Rush..................................................................................... 32
    2.7 Programas em Rush .................................................................................................... 33
    2.7.1 Fluxos de entrada e saída...................................................................................... 33
    2.7.2 Utilização de valores numéricos ........................................................................... 38
    2.7.3 Outras operações numéricas ................................................................................ 42
    2.7.4 Definição de constantes........................................................................................ 48
    2.7.5 Valores lógicos..................................................................................................... 50
    2.7.6 Operações matemáticas ....................................................................................... 51
    2.8 Linhas de comentários................................................................................................ 52
    6 Primeiros passos com a linguagem Rust
    2.9 Mensagens de advertência ........................................................................................... 54
    2.10 Exercícios de fixação ................................................................................................. 56

    Capítulo 3 ¦ Desvio condicional................................................................................................58
    3.1 Condição e decisão ..................................................................................................... 58
    3.2 Desvios condicionais................................................................................................... 59
    3.2.1 Desvio condicional simples.................................................................................. 59
    3.2.2 Desvio condicional composto .............................................................................. 61
    3.3 Operadores lógicos ..................................................................................................... 62
    3.3.1 Operador lógico de conjunção.............................................................................. 63
    3.3.2 Operador lógico de disjunção...............................................................................64
    3.3.3 Operador lógico de negação.................................................................................66
    3.4 Outros desvios condicionais........................................................................................ 67
    3.4.1 Desvio condicional encadeado.............................................................................. 67
    3.4.2 Desvio condicional sequencial.............................................................................. 69
    3.4.3 Operador condicional .......................................................................................... 72
    3.5 Controle com múltipla escolha .................................................................................... 73
    3.6 Divisibilidade.............................................................................................................. 78
    3.7 Validação do fluxo de entrada...................................................................................... 82
    3.8 Exercícios de fixação...................................................................................................86

    Capítulo 4 ¦ Laços ...................................................................................................................88
    4.1 Laço pré-teste .............................................................................................................88
    4.2 Laço seletivo............................................................................................................... 95
    4.3 Laço iterativo..............................................................................................................98
    4.4 Interrupção na execução de laços .............................................................................. 100
    4.5 Jogo de adivinhação.................................................................................................. 102
    4.6 Exercícios de fixação................................................................................................. 106

    Capítulo 5 ¦ Sub-rotinas........................................................................................................108
    5.1 Dividir para conquistar ............................................................................................. 108
    5.2 Paradigmas top-down e bottom-up ........................................................................... 109
    5.3 Sub-rotinas em Rust.................................................................................................. 110
    5.4 Escopo e visibilidade de variáveis............................................................................... 111
    5.5 Sub-rotina: procedimento ......................................................................................... 113
    5.6 Passagem de parâmetro ............................................................................................. 116
    5.6.1 Passagem de parâmetro por valor ....................................................................... 117
    5.6.2 Passagem de parâmetro por referência ................................................................ 118
    5.7 Sub-rotina: função .................................................................................................... 120
    5.7.1 Função básica .................................................................................................... 121
    5.7.2 Função recursiva................................................................................................ 124
    5.7.3 Função apontada................................................................................................ 126
    5.8 Sub-rotina como parâmetro....................................................................................... 128
    5.9 Sub-rotina fechada .................................................................................................... 130
    5.10 Exercícios de fixação ............................................................................................... 135

    Capítulo 6 ¦ Complementos................................................................................................... 138
    6.1 Conversão de tipos.................................................................................................... 138
    6.2 Ponteiros ...................................................................................................................141
    6.2.1 Ponteiro de referência......................................................................................... 142
    6.2.2 Ponteiro exclusivo.............................................................................................. 145
    6.2.3 Ponteiro bruto ................................................................................................... 148
    6.3 Terminal ANSI ......................................................................................................... 150
    6.4 Biblioteca definida pelo programador ........................................................................ 157
    6.5 Metaprogramação com macros.................................................................................. 161
    6.6 Laço iterativo compassado ........................................................................................ 163
    6.7 Caracteres ASCII, Unicode e Byte.............................................................................. 165

    Capítulo 7 ¦ Estruturas homogêneas...................................................................................... 169
    7.1 Matriz estática .......................................................................................................... 169
    7.1.1 Matriz unidimensional ....................................................................................... 169
    7.1.2 Matriz bidimensional ..........................................................................................174
    7.1.3 Matriz interna.................................................................................................... 177
    7.2 Matriz dinâmica........................................................................................................ 179
    7.2.1 Matriz unidimensional....................................................................................... 180
    7.2.2 Matriz bidimensional......................................................................................... 182
    7.3 Fatiamento de matriz ................................................................................................ 184
    7.4 Ordenação e pesquisa................................................................................................ 185
    7.4.1 Ordenação de elementos matriciais..................................................................... 185
    7.4.2 Pesquisa de elementos matriciais ........................................................................ 188
    7.5 Iteradores.................................................................................................................. 194
    7.6 Exercícios de fixação .................................................................................................200

    Capítulo 8 ¦ Estruturas heterogêneas ....................................................................................204
    8.1 Tuplas de dados ........................................................................................................ 204
    8.2 Estruturas................................................................................................................. 207
    8.2.1 Estrutura clássica .............................................................................................. 208
    8.2.2 Estrutura tupla.................................................................................................. 211
    8.2.3 Estrutura-unidade ............................................................................................. 213
    8.3 Enumerações............................................................................................................ 215
    8.4 Agregações ...............................................................................................................223
    8.5 Definições de traços.................................................................................................. 226
    8.6 Exercícios de fixação................................................................................................. 237

    Capítulo 9 ¦ Suplementos......................................................................................................239
    9.1 Programação genérica ............................................................................................... 239
    9.1.1 Funções............................................................................................................. 239
    9.1.2 Estruturas.......................................................................................................... 247
    9.2 Programação funcional ............................................................................................. 251
    9.3 Tratamento de erros e exceções ................................................................................. 259
    9.4 Data e hora ............................................................................................................... 264
    9.5 Coleções................................................................................................................... 275
    9.6 Cadeias e caracteres.................................................................................................. 283
    9.7 Criptografia .............................................................................................................. 294
    9.8 Armazenamento básico de dados............................................................................... 305
    Referências bibliográficas...................................................................................................... 311

    Informações Técnicas

    Nº de páginas:312
    Origem:Nacional
    Editora:Editora Novatec
    Idioma:Português
    Edição:1ª Edição
    Ano:2018
    ISBN:9788575226834
    Encadernação:Brochura
    Autor:José Augusto N. G. Manzano
  • Informações

Avaliação técnica sobre o livro

Não encontrou seu produto? Deixe aqui sua Sugestão para novos produtos!

Enviar sugestão

Políticas

Informações

Atendimento

(21) 2262-3111

(21) 2262-3111

Pague com

Visa, mastercard, Diners, Boleto, American Express , VisaElectron, Discover , Elo , Maestro

Segurança e certificados

© 2015 Livraria Ciência Moderna Ltda - Avenida Rio Branco 156 – subsolo 126 – Centro – RJ – Cep:20040-003 | Cnpj :33.412.271/0001-03 | Inscrição Estadual: 85.853.198 *Os preços e condições de pagamento podem ser exclusivos para compras via internet , o que quer dizer que podem variar das lojas físicas. Vendas Sujeitas á analise e confirmação de dados.
VTEXOriginal Media

Olá! Seja Bem Vindo (a)!

Eu sou o Moderninho , o Mascote da Ciência Moderna Online!
Além de bonito, o novo site tem Minhas Dicas :) #ficaadica

A 1ª Dica é -> Deixe aqui seu contato para receber nossas
NOVIDADES, PROMOÇÕES E CUPONS DE DESCONTOS ;)

Navegue SEM Moderação!