Menu

Tech

COMEÇAR A APRENDER

Português

Declarando Variáveis de Ponteiro

Parte da seção Fundamentos do Journey de GO da Coddy — lição 61 de 109.

Em Go, você pode declarar ponteiros de duas formas principais: usando var com um tipo de ponteiro ou usando o operador de endereço com :=.

Declare um ponteiro usando var com um tipo de ponteiro:

func main() {
    var x int = 42
    var ptr *int    // Declara um ponteiro para um inteiro
    ptr = &x        // Atribui o endereço de x a ptr
    
    fmt.Println("Value of x:", x)
    fmt.Println("Value of ptr:", ptr)
    fmt.Println("Value at ptr:", *ptr)
}

A saída mostra que o ponteiro armazena o endereço de x:

Value of x: 42
Value of ptr: 0xc000018030
Value at ptr: 42

Você também pode declarar e inicializar um ponteiro em uma única linha usando :=:

y := 100
ptr := &y    // Declara e inicializa o ponteiro em um único passo

Desafio

Iniciante

Neste desafio, você praticará a declaração e o uso de ponteiros em Go. Um ponteiro já está configurado para você, e sua tarefa é criar um novo ponteiro que aponte para o mesmo valor.

Complete o TODO no código para declarar uma nova variável de ponteiro chamada 'secondPointer' que aponte para o mesmo endereço de memória que o ponteiro existente.

Folha de consulta

Em Go, você pode declarar ponteiros usando var com um tipo de ponteiro ou usando o operador de endereço com :=.

Declare um ponteiro usando var:

var x int = 42
var ptr *int    // Declare a pointer to an integer
ptr = &x        // Assign the address of x to ptr

Declare e inicialize um ponteiro em uma única linha usando :=:

y := 100
ptr := &y    // Declare and initialize pointer in one step

Acesse os valores do ponteiro:

ptr - o endereço de memória
*ptr - o valor naquele endereço

Experimente você mesmo

package main

import "fmt"

func main() {
	// Aqui está uma variável e um ponteiro para ela
	originalValue := 42
	pointerToValue := &originalValue
	
	// TODO: Declare uma nova variável de ponteiro chamada 'secondPointer' 
	// que aponta para o mesmo endereço de memória que 'pointerToValue'
	
	
	// Não modifique o código abaixo
	fmt.Printf("Original value: %v\n", originalValue)
	fmt.Printf("Value through first pointer: %v\n", *pointerToValue)
	fmt.Printf("Value through second pointer: %v\n", *secondPointer)
	
	// Vamos alterar o valor original e ver todos os ponteiros refletirem a mudança
	originalValue = 100
	fmt.Printf("\nAfter changing original value to 100:\n")
	fmt.Printf("Original value: %v\n", originalValue)
	fmt.Printf("Value through first pointer: %v\n", *pointerToValue)
	fmt.Printf("Value through second pointer: %v\n", *secondPointer)
}

Teste seus conhecimentos

Esta lição inclui um quiz rápido. Comece a lição para respondê-lo e acompanhar seu progresso.

Todas as lições de Fundamentos

1Introdução ao Go

O que é Go?Hello World Println Comentários em Go

4Operadores de Comparação e Lógicos

Operadores de Comparação - Parte 1 Operadores de Comparação - Parte 2 Operador Lógico AND Operador Lógico OR Operador Lógico NOT Fundamentos de Precedência de Operadores Recapitulação - Fazendo Comparações

7Fluxo de Controle: Loops

O Loop `for` Explicado Loop For - Básico Loop For - Apenas Condição A Palavra-chave `break`A Palavra-chave `continue`Loops Aninhados Recapitulação - Repetindo Ações

10Tipos Compostos: Arrays

Introdução a Arrays Declarando Arrays Inicializando Arrays Acessando Elementos de um Array Tamanho do Array com `len`Iterando sobre Arrays Arrays Multidimensionais

13Tipos Compostos: Structs

Definindo Tipos Personalizados Criando Instâncias de Structs Acessando Campos de Structs Ponteiros para Structs Inicializando Structs Structs Incorporadas Structs Anônimas Recapitulação - Estruturas de Dados Personalizadas

2Variáveis e Tipos de Dados Básicos

O que é uma variável Inferência de Tipo com `:=`Inteiros (int)Números de Ponto Flutuante Booleanos Strings Valores Zero Constantes Convenções de Nomenclatura Recapitulação - Variáveis e Tipos

5Entrada/Saída Básica

Saída Formatada Verbos de Formatação Imprimindo Tipos Obtendo Entrada Básica do Usuário Recapitulação - Entrada e Saída

8Funções

Entendendo Funções Declarando uma Função Chamando Funções Parâmetros de Função Retornando um Único Valor Retornando Múltiplos Valores Valores de Retorno Nomeados Fundamentos de Escopo de Função Recapitulação - Criando Código Reutilizável

11Tipos Compostos: Slices

Introdução aos Slices Declarando Literais de Slice Criando Slices com `make`Comprimento vs Capacidade de Slices Acessando Elementos de Slices Adicionando Elementos Fatiando Slices/Arrays Existentes Iterando sobre Slices Copiando Slices Recapitulação - Listas Dinâmicas

14Tratamento de Erros Básico

O Conceito de Erros A Interface `error`Funções que Retornam Erros Verificando Erros Criando Erros Simples Criando Erros Formatados Tratamento de Erros Básico Recapitulação - Lidando com Problemas

3Operadores Básicos

Operadores Aritméticos Operador de Divisão O Operador Módulo Operador de Atribuição Operadores de Atribuição Composta Incremento e Decremento Recapitulação - Cálculos

6Fluxo de Controle: Condicionais

A Instrução `if`A Palavra-chave `else`A Palavra-chave `else if`Sombreamento de Variáveis no `if`Inicializando Variáveis A Instrução `switch`Switch com Expressões Switch sem Expressão A Palavra-chave `fallthrough`Recapitulação - Tomando Decisões

9Ponteiros

O que é um Ponteiro?Declarando Variáveis de PonteiroO Operador de Endereço Desreferenciando Ponteiros Usando Ponteiros em Funções Ponteiros Nil Recapitulação - Entendendo Ponteiros

12Tipos Compostos: Mapas

Introdução a Mapas Declarando Literais de Mapas Criando Mapas com `make`Adicionando e Atualizando Chave-Valor Acessando Valores de Mapas Verificando a Existência de Chaves Deletando Entradas de Mapas Tamanho do Mapa Iterando sobre Mapas Recapitulação - Armazenamento Chave-Valor