Como usar ponteiros C ++
O endereço de operador, &
Este é um operador unário. Quando seguido por um identificador, ele retorna o endereço do objeto do identificador. Considere a seguinte declaração:
int ptdint;
Abaixo está o código, a seguinte expressão, retornará o endereço identificado por Ptdint:
& ptdint
Você não precisa saber o endereço exato (número) enquanto codifica.
O operador indiretivo, *
Este é um operador unário no contexto de ponteiros. Geralmente é digitado na frente de um identificador. Se usado em uma declaração do identificador, o identificador é o objeto de ponteiro que mantém apenas o endereço do objeto pontiagudo. Se usado na frente do identificador do objeto Ponte.
Criando um ponteiro
Dê uma olhada no seguinte segmento de código:
flutuar ptdfloat;
flutuar *ptrfloat;
ptrfoat = &ptdFloat;
O segmento começa com a declaração do objeto pontiagudo, ptdfloat. ptdfloat é um identificador, que apenas identifica um objeto flutuante. Um objeto real (valor) poderia ter sido atribuído a ele, mas neste caso, nada foi atribuído a ele. Em seguida no segmento, há a declaração do objeto de ponteiro. O operador indiretivo na frente desse identificador significa que ele deve manter o endereço de um objeto pontiagudo. O tipo de objeto, flutuando no início da declaração, significa que o objeto pontiagudo é um flutuador. O objeto Pointer é sempre do mesmo tipo que o objeto pontiagudo. ptrfoat é um identificador, que apenas identifica um objeto de ponteiro.
Na última declaração do código, o endereço do objeto pontiagudo é atribuído ao objeto Pointer. Observe o uso do endereço do operador, &.
A última declaração (linha) acima mostra que, depois de declarar o objeto de ponteiro sem inicialização, você não precisa do operador de indireção, quando precisar inicializá -lo. De fato, é um erro de sintaxe usar o operador de indireção na terceira (última) linha.
O objeto Pointer pode ser declarado e inicializado pelo objeto pontiagudo em uma declaração, como segue:
flutuar ptdfloat;
flutuar *ptrfoat = &ptdFloat;
A primeira linha do segmento de código anterior e esta é a mesma. A segunda e a terceira linhas do segmento de código anterior foram combinadas em uma declaração aqui.
Observe no código acima que, ao declarar e inicializar o objeto de ponteiro, o operador de indireção deve ser usado. No entanto, não é usado se a inicialização for feita depois. O objeto Pointer é inicializado com o endereço do objeto pontiagudo.
No segmento de código a seguir, o operador de indireção é usado para retornar o conteúdo do objeto pontiagudo.
int ptdint = 5;
int *pTrint = &ptdInt;
cout << *ptrInt << '\n';
A saída é 5.
Na última declaração aqui, o operador de indireção foi usado para devolver o valor apontado pelo identificador de ponteiro. Assim, quando usado em uma declaração, o identificador para o operador indiretor manteria o endereço do objeto pontiagudo. Quando usado em uma expressão de retorno, em combinação com o identificador de ponteiro, o operador indiretivo retorna o valor do objeto pontiagudo.
Atribuindo zero a um ponteiro
O objeto Pointer deve sempre ter o tipo de objeto pontiagudo. Ao declarar o objeto de ponteiro, o tipo de dados do objeto pontiagudo deve ser usado. No entanto, o valor do zero decimal pode ser atribuído ao ponteiro, como no segmento de código a seguir:
int ptdint = 5;
int *ptrint;
pTrint = 0;
ou no segmento,
int ptdint = 5;
int *pTrint = 0;
Em ambos os casos, o ponteiro (identificador) é chamado de ponteiro nulo; Significado, aponta para lugar nenhum. Isto é, ele não tem o endereço de nenhum objeto pontiagudo. Aqui, 0 é decimal zero e não é hexadecimal zero. Zero hexadecimal apontaria para o primeiro endereço da memória do computador.
Não tente obter o valor apontado por um ponteiro nulo. Se você tentar isso, o programa poderá compilar, mas não pode executar.
Nome da matriz como um ponteiro constante
Considere a seguinte matriz:
int arr [] = 000, 100, 200, 300, 400;
O nome da matriz, ARR é na verdade o identificador que tem o endereço do primeiro elemento da matriz. A expressão a seguir retorna o primeiro valor na matriz:
*arr
Com a matriz, o operador de incremento, ++ se comporta de maneira diferente. Em vez de adicionar 1, ele substitui o endereço do ponteiro, com o endereço do próximo elemento na matriz. No entanto, o nome da matriz é um ponteiro constante; o que significa que seu conteúdo (endereço) não pode ser alterado ou incrementado. Portanto, para incrementar, o endereço inicial da matriz deve ser atribuído a um ponteiro não constante da seguinte maneira:
int *ptr = arr;
Agora, a PTR pode ser incrementada para apontar para o próximo elemento da matriz. PTR foi declarado aqui como um objeto de ponteiro. Sem * aqui, não seria um ponteiro; Seria um identificador manter um objeto int e não segurar um endereço de memória.
O segmento de código a seguir finalmente aponta para o quarto elemento:
++ptr;
++ptr;
++ptr;
O código a seguir gera o quarto valor da matriz:
int arr [] = 000, 100, 200, 300, 400;
int *ptr = arr;
++ptr;
++ptr;
++ptr;
cout << *ptr << '\n';
A saída é 300.
Nome da função como identificador
O nome de uma função é o identificador da função. Considere a seguinte definição de função:
int fn ()
cout << "seen" << '\n';
retornar 4;
FN é o identificador da função. A expressão,
& fn
Retorna o endereço da função na memória. FN é como o objeto pontiagudo. A declaração a seguir declara um ponteiro para uma função:
int (*func) ();
O identificador para o objeto pontiagudo e o identificador para o objeto de ponteiro são diferentes. func é um ponteiro para uma função. FN é o identificador de uma função. E assim, Func pode ser feito para apontar para FN da seguinte maneira:
func = &fn;
O valor (conteúdo) do func é o endereço do FN. Os dois identificadores poderiam ter sido vinculados a uma declaração de inicialização da seguinte forma:
int (*func) () = &fn;
Observe as diferenças e semelhanças no manuseio de ponteiros de funções e indicadores escalares. func é um ponteiro para uma função; é o objeto pontiagudo; é declarado de maneira diferente de um ponteiro escalar.
A função pode ser chamada com,
fn ()
ou
func ()
Não pode ser chamado com *func ().
Quando a função tem parâmetros, os segundos parênteses têm os tipos de parâmetros e não precisam ter os identificadores para os parâmetros. O programa a seguir ilustra o seguinte:
#incluir
usando namespace std;
flutuar fn (flutuar fl, int in)
retornar fl;
int main ()
float (*func) (float, int) = &fn;
flutuar val = func (2.5, 6);
cout << val << '\n';
retornar 0;
A saída é 2.5.
Referência C ++
A referência em C ++ é apenas uma maneira de produzir um sinônimo (outro nome) para um identificador. Ele usa o Operador, mas não da mesma maneira que & é usado para ponteiros. Considere o seguinte segmento de código:
int myint = 8;
int & yourint = myint;
cout << myInt << '\n';
cout << yourInt << '\n';
A saída é:
8
8
A primeira declaração inicializa o identificador, myint; eu.e. Myint é declarado e feito para manter o valor, 8. A segunda declaração faz um novo identificador, seu sinônimo de myint. Para conseguir isso, o Operador é colocado entre o tipo de dados e o novo identificador na declaração. As declarações cout mostram que os dois identificadores são sinônimos. Para retornar o valor neste caso, você não precisa precedi -lo com * . Basta usar o identificador.
Myint e Yourint aqui, não são dois objetos diferentes. São dois identificadores diferentes que referenciam (identificando) o mesmo local na memória com o valor, 8. Se o valor do myint for alterado, o valor do seu dia também mudará automaticamente. Se o valor do seu dia for alterado, o valor do myint também mudará automaticamente.
As referências são do mesmo tipo.
Referência a uma função
Assim como você pode ter uma referência a um escalar, você também pode ter uma referência a uma função. No entanto, codificar uma referência a uma função é diferente de codificar uma referência a um escalar. O programa a seguir ilustra o seguinte:
#incluir
usando namespace std;
flutuar fn (flutuar fl, int in)
retornar fl;
int main ()
float (& func) (float, int) = fn;
flutuar val = func (2.5, 6);
cout << val << '\n';
retornar 0;
A saída é 2.5.
Observe a primeira declaração na função principal, que faz do FUNC um sinônimo de FN. Ambos referenciam a mesma função. Observe o uso único e a posição de &. Então e o operador de referência é aqui e não o endereço de operador. Para chamar a função, basta usar qualquer um dos nomes.
Um identificador de referência não é o mesmo que um identificador de ponteiro.
Função retornando um ponteiro
No programa a seguir, a função retorna um ponteiro, que é o endereço do objeto apontado:
#incluir
usando namespace std;
flutuar *fn (flutuar fl, int in)
flutuar *fll = &fl;
retornar fll;
int main ()
flutuar *val = fn (2.5, 6);
cout << *val << '\n';
retornar 0;
A saída é 2.5
A primeira declaração na função, fn () existe apenas para criar um objeto de ponteiro. Observe o uso único e a posição de * na assinatura da função. Observe também como o ponteiro (endereço) foi recebido na função principal () por outro objeto de ponteiro.
Função retornando uma referência
No programa a seguir, a função retorna uma referência:
#incluir
usando namespace std;
Float & Fn (Float fl, int in)
flutuador & frr = fl;
retornar frr;
int main ()
Float & Val = Fn (2.5, 6);
cout << val << '\n';
retornar 0;
A saída é 2.5.
A primeira declaração na função, fn () existe apenas para criar uma referência. Observe o uso único e a posição de e na assinatura da função. Observe também como a referência foi recebida na função principal () por outra referência.
Passando um ponteiro para uma função
No programa a seguir, um ponteiro, que é na verdade o endereço de um objeto apontado por flutuação, é enviado como um argumento para a função:
#incluir
usando namespace std;
Float fn (Float *fl, int in)
retornar *fl;
int main ()
Float V = 2.5;
flutuar val = fn (& v, 6);
cout << val << '\n';
retornar 0;
A saída é 2.5
Observe o uso e a posição de * para o parâmetro flutuante na assinatura da função. Assim que a avaliação da função fn () é iniciada, a seguinte declaração é feita:
flutuar *fl = & v;
Ambos FL e & V estão apontando para o mesmo objeto pontiagudo que contém 2.5. *FL na declaração de devolução não é uma declaração; Significa que o valor do objeto apontado apontado pelo objeto Ponteiro.
Passando uma referência a uma função
No programa a seguir, uma referência é enviada como um argumento para a função:
#incluir
usando namespace std;
Float fn (Float & FL, int in)
retornar fl;
int main ()
Float V = 2.5;
flutuar val = fn (v, 6);
cout << val << '\n';
retornar 0;
A saída é 2.5
Observe o uso e a posição do parâmetro FLOAT na assinatura da função. Assim que a avaliação da função fn () é iniciada, a seguinte declaração é feita:
float & fl = v;
Passando uma matriz para uma função
O programa a seguir mostra como passar uma matriz para uma função:
#incluir
usando namespace std;
int fn (int arra [])
retornar Arra [2];
int main ()
int arr [] = 000, 100, 200, 300, 400;
int val = fn (arr);
cout << val << '\n';
retornar 0;
A saída é 200.
Neste programa, é a matriz que é passada. Observe que o parâmetro da assinatura da função tem uma declaração de matriz vazia. O argumento na chamada de função é apenas o nome de uma matriz criada.
Uma função C ++ pode retornar uma matriz?
Uma função em C ++ pode retornar o valor de uma matriz, mas não pode retornar a matriz. A compilação do programa a seguir resulta em uma mensagem de erro:
#incluir
usando namespace std;
int fn (int arra [])
retornar Arra;
int main ()
int arr [] = 000, 100, 200, 300, 400;
int val = fn (arr);
retornar 0;
Ponteiro de um ponteiro
Um ponteiro pode apontar para outro ponteiro. Isto é, um objeto de ponteiro pode ter o endereço de outro objeto de ponteiro. Eles ainda devem ser do mesmo tipo. O seguinte segmento de código ilustra o seguinte:
int ptdint = 5;
int *pTrint = &ptdInt;
int ** ptrpTrint = &ptrInt;
cout << **ptrptrInt << '\n';
A saída é 5.
Na declaração de ponteiro a ponto, o dobro * é usado. Para retornar o valor do objeto final pontual, o dobro * ainda é usado.
Matriz de ponteiros
O programa a seguir mostra como codificar uma variedade de ponteiros:
#incluir
usando namespace std;
int main ()
int num0 = 000, num1 = 100, num2 = 200, num3 = 300, num4 = 400;
int *no0 = & num0, *no1 = & num1, *no2 = & num2, *no3 = & num3, *no4 =&num4;
int *arr [] = no0, no1, no2, no3, no4;
cout << *arr[4] << '\n';
retornar 0;
A saída é:
400
Observe o uso e a posição de * na declaração da matriz. Observe o uso de * ao retornar um valor na matriz. Com ponteiros de ponteiros, dois * estão envolvidos. No caso de matriz de ponteiros, um * já foi resolvido, porque o identificador de matriz é um ponteiro.
Matriz de seqüências de comprimento variável
Uma corda literal é uma constante que retorna um ponteiro. Uma variedade de cordas de comprimento variável é uma variedade de dicas. Cada valor na matriz é um ponteiro. Ponteiros são endereços para locais de memória e são do mesmo tamanho. As cordas dos diferentes comprimentos estão em outros lugares da memória, não na matriz. O programa a seguir ilustra o uso:
#incluir
usando namespace std;
int main ()
const char *arr [] = "mulher", "menino", "menina", "adulto";
cout << arr[2] << '\n';
retornar 0;
A saída é "garota".
A declaração da matriz começa com a palavra reservada, "const" para constante; seguido de "char" para o personagem, depois o asterisco, * para indicar que cada elemento é um ponteiro. Para devolver uma string da matriz, * não é usado, devido à natureza implícita do ponteiro de cada string. Se * for usado, o primeiro elemento da string será devolvido.
Ponteiro para uma função retornando um ponteiro
O programa a seguir ilustra como um ponteiro para uma função que retorna um ponteiro é codificado:
#incluir
usando namespace std;
int *fn ()
int num = 4;
int *inter = #
retornar inter;
int main ()
int *( *func) () = &fn;
int val = *func ();
cout << val << '\n';
retornar 0;
A saída é 4.
A declaração de um ponteiro para uma função que retorna um ponteiro é semelhante à declaração de um ponteiro a uma função comum, mas precedida com um asterisco. A primeira declaração na função Main () ilustra esta. Para chamar a função usando o ponteiro, precede -o com *.
Conclusão
Para criar um ponteiro para um escalar, faça algo como,
flutuar apontado;
Float *ponteiro = &pointed;
* tem dois significados: em uma declaração, está indicando um ponteiro; Para devolver algo, é para o valor do objeto pontiagudo.
O nome da matriz é um ponteiro constante para o primeiro elemento da matriz.
Para criar um ponteiro para uma função, você pode fazer,
int (*func) () = &fn;
onde fn () é uma função definida em outro lugar e func é o ponteiro.
& tem dois significados: em uma declaração, indica uma referência (sinônimo) ao mesmo objeto que outro identificador; Ao devolver algo, significa o endereço de.
Para criar uma referência a uma função, você pode fazer,
float (& reffunc) (float, int) = fn;
onde fn () é uma função definida em outro lugar e reffunc é a referência.
Quando uma função retorna um ponteiro, o valor retornado deve ser recebido por um ponteiro. Quando uma função retorna uma referência, o valor retornado deve ser recebido por uma referência.
Ao passar um ponteiro para uma função, o parâmetro é uma declaração, enquanto o argumento é o endereço de um objeto pontual. Ao passar uma referência a uma função, o parâmetro é uma declaração, enquanto o argumento é a referência.
Ao passar uma matriz para uma função, o parâmetro é uma declaração enquanto o argumento é o nome da matriz sem []. A função C ++ não retorna uma matriz.
Um ponteiro para apontar precisa de dois * em vez de um, quando apropriado.