Меню

Указатели и операции на показалеца в C ++

pointers pointer operations c

Опитайте Нашия Инструмент За Премахване На Проблемите

Интензивно проучване на указателите и тяхното използване в C ++.

Указателят е една от най-мощните функции на езика C ++. Указателят помага да се манипулират променливите чрез неговия адрес.

колко можете да спечелите от потребителско тестване

В този урок ще разгледаме подробно всичко за указателите и тяхното използване в C ++.

=> Внимавайте тук за простият сериал за обучение на C ++.

Указатели в c ++

Какво ще научите:

Какво е показалец?

Указателят е променлива, която съдържа адреса на място в паметта. Знаем, че всички променливи, които декларираме, имат определен адрес в паметта. Декларираме променлива на указател, която да сочи към тези адреси в паметта.

Общият синтаксис за деклариране на променлива на указателя е:

datatype * variable_name;

Например, декларацията int * ptr;

Това означава, че ptr е указател, който сочи към променлива от тип int. Следователно променливата на указателя винаги съдържа местоположение или адрес в паметта. Нека видим работата на променливите на указателя по-долу.

Помислете, че имаме следните декларации:

Int p, *ptr; //declare variable p and pointer variable ptr p = 4; //assign value 4 to variable p ptr = &p; //assign address of p to pointer variable ptr

В памет тези декларации ще бъдат представени по следния начин:

разпределение на паметта на указателите

Това е вътрешното представяне на показалеца в паметта. Когато присвояваме адресната променлива на променливата на указателя, тя сочи към променливата, както е показано в представлението по-горе.

Тъй като ptr има адрес на променлива p, * ptr ще даде стойността на променлива p (променлива, към която сочи променливата на указателя ptr).

Забележка: Операторът *, който използваме с показалеца, се използва за означаване, че той е променлива на указателя.

Нека видим някои от концепциите на указателите, които се използват в C ++.

Аритметика на показалеца

Знаем, че променливата на указателя винаги сочи към адреса в паметта. Сред операциите, които можем да изпълним, имаме следните аритметични операции, които се извършват върху указатели.

  • Оператор на приращение (++)
  • Оператор на декремент (-)
  • Добавяне (+)
  • Изваждане (-)

Нека да видим използването на тези операции в примерна програма.

#include #include using namespace std; int main() { int myarray(5) = {2, 4,6, 8,10}; int* myptr; myptr = myarray; cout<<'First element in the array :'<<*myptr<

Изход:

Първи елемент в масива: 2
следващ елемент в масива: 4
следващ елемент в масива: 6
следващ елемент в масива: 4
следващ елемент в масива: 2

Виждали сме аритметични операции, извършвани върху указатели. Обърнете внимание, че операторът на инкремент ++ увеличава показалеца и сочи към следващия елемент в масива. По подобен начин операторът на декрементиране намалява показалечната променлива с 1, така че да сочи към предишния елемент в масива.

Използваме и оператори + и -. Първо, добавихме 1 към променливата на указателя. Резултатът показва, че той сочи към следващия елемент в масива. По подобен начин - - операторът прави променливата на указателя, за да сочи към предишния елемент в масива.

Освен тези аритметични оператори, можем да използваме и оператори за сравнение като ==,.

Null And Void указатели

Ако в случай, на променлива на указател не е присвоен адрес на променлива, тогава е добра практика да се присвоява стойност NULL на променливата на указателя. Променливата на указателя със стойност NULL се нарича NULL указател.

Нулевият указател е постоянен указател със стойност нула, дефинирана в заглавката на iostream. Паметта на адрес 0 е запазена от операционната система и нямаме достъп до това местоположение.

Използвайки нулевия указател, можем да избегнем злоупотребата с неизползвани указатели и да предотвратим присвояване на някои стойности на боклука на променливите.

Кухи указатели са специалните указатели, които сочат към стойностите без тип. Указателите за празнота са по-гъвкави, тъй като могат да сочат към всеки тип. Но те не могат да бъдат директно преориентирани. За преориентиране указателят void трябва да бъде преобразуван в указател, който сочи към стойност с конкретния тип данни.

Показахме работата на указателя NULL и указателя void в следния пример за код.

#include #include using namespace std; int main() { int intvar = 10; char c = 'A'; void* vptr; int* myptr = NULL; cout<<'NULL pointer value :'<

Изход:

NULL стойност на показалеца: 0
Показалецът за празно място vptr сочи към: A
Показалецът за празно място vptr сочи към: 10

В горната програма първо декларираме целочислен указател, на който е присвоена стойност NULL. Когато отпечатваме този указател, виждаме, че стойността е 0, както сме обсъждали по-рано.

След това декларираме празен указател. Първо, ние присвояваме адрес на символна променлива на този празен указател. След това присвояваме указател void на указател на символ и го въвеждаме с char *. След това отпечатваме стойност charptr, която сочи към char A, която е променлива на символа, която декларирахме по-рано и е посочена от указателя void.

как да отворя apk файл на android

След това сме присвоили целочислена променлива на указателя за void и след това изпълняваме същите стъпки на пренасочване на този void указател с помощта на цяло число указател.

Масиви и указатели

Масивите и указателите са силно свързани помежду си. Знаем, че името на масива сочи към първия елемент в масива и това е постоянен указател.

Можем да присвоим този указател на променлива на указател и след това да осъществим достъп до масива или чрез декрементиране на указателя, или чрез използване на оператора на индекса.

Ще видим тази връзка между променливата на указателя и масива в следващия пример за код.

#include #include using namespace std; int main() { int myarray(5) = {1, 1, 2, 3, 5}; int* ptrvar; ptrvar = myarray; for(int i=0;i<5;i++) { cout<<*ptrvar<<' '; ptrvar++; } return 0; }

Изход:

1 1 2 3 5

В горната програма ние присвояваме името на масива на променлива на указател. Тъй като името на масива сочи към първия елемент в масива, ние можем да отпечатаме съдържанието на целия масив, като използваме указател на променлива и да го увеличим с помощта на оператора ++. Това е показано в изхода.

Масив от указатели

Понякога се нуждаем от повече от една променлива на указател в програма. Вместо да декларираме всяка отделна променлива на показалеца, можем да декларираме масив от указатели.

Нека веднага вземем пример, за да демонстрираме набор от указатели.

#include #include using namespace std; int main() { int myarray(5) = {2,4,6,8,10}; int *ptr(5); //array of pointers for(int i=0;i<5;i++){ ptr(i) = &myarray(i); } for (int i = 0; i < 5; i++) { cout << 'Value of myarray(' << i << ') = '; cout << *ptr(i) << endl; } return 0; }

Изход:

Стойност на myarray (0) = 2
Стойност на myarray (1) = 4
Стойност на myarray (2) = 6
Стойност на myarray (3) = 8
Стойност на myarray (4) = 10

В декларацията по-горе,

int * ptr (5);

Можем да тълкуваме като; ptr е масив от 5 целочислени указателя. Следователно всеки елемент на ptr ще сочи към променлива от тип цяло число.

Използваме масив от цяло число и присвояваме адреса на всеки елемент от масива на всеки от елементите ptr. След това показваме съдържанието на масива ptr, като изведем “* ptr (i)”.

Показалец на указателите

Показалецът на указателите не е нищо друго освен множество косвени. Това е един вид верига от указатели. Когато дефинираме указател на указатели, първият указател има адрес на втория указател, който от своя страна има адреса на променливата, към която сочи.

В памет това ще бъде представено като:

Показалец за разпределение на паметта на указатели

Показалецът от указатели се декларира, както следва:

int** intptr;

Вземаме директно пример за код, за да разберем по-добре указателя на указателите.

#include #include using namespace std; int main() { int *vptr; int ** intptr; int var = 10; vptr = &var; intptr = &vptr; cout<<'Variable var: '<

Изход:

Променлива var: 10
Показалец към променлива: 10
Показалец към указател към променлива: 10

В горната програма декларираме целочислена променлива, целочислен указател и указател на указател към цяло число. Както е показано в програмата, на променливата на указателя се присвоява стойността на променлива. На показалеца на променливата на указателя се присвоява адресът на променливата на показалеца.

В крайна сметка отпечатваме трите променливи, които показват една и съща стойност 10, равна на целочислена променлива.

Предаване на указатели към функции

Предаването на указатели към функция е същото като другите техники за предаване на параметри, при които предаваме променливи на указателя към функцията.

Преразглеждаме нашите суап две стойности и го модифицираме, за да предадем променливите на указателя като параметри.

#include #include using namespace std; void swap(int* a, int* b) { int temp; temp = *a; *a = *b; *b = temp; } int main() { int a, b; cout<>a>>b; cout<<'a = '< Функционални указатели

по същия начин, тъй като имаме указатели към променливи, масиви и т.н., можем да имаме указатели и към функции. Но разликата е, че указателят на функцията сочи към изпълнимия код, а не към данни като променливи или масиви.

Вземаме пример, за да демонстрираме указатели на функциите.

#include #include using namespace std; void displayVal(int a) { printf('Value of a is %d ', a); } int main() { void (*func_ptr)(int) = &displayVal; (*func_ptr)(100); return 0; }

Изход:

Стойността на a е 100

въпроси на интервю за ръководител на екип, базирани на сценарий

В горната програма имаме функция ‘displayVal’, която просто отпечатва целочислена стойност, предадена към нея. В основната функция дефинирахме указател на функция ‘func_ptr’, който приема int като аргумент и връща тип void.

void (* func_ptr) (int)

Забележка: Трябва да приложим показалеца на функция вътре (). Ако го пропуснем, той ще се превърне във прототип на функция.

На този указател на функцията сме присвоили адреса на функцията ‘displayVal’. След това, използвайки този функционален указател ‘func_ptr’, ние предаваме стойността на аргумента 100, което е еквивалентно на извикване на displayVal с аргумент 100.

Сега, ако имаме друга функция със същия прототип, тогава можем да използваме същия указател на функцията, като му присвоим адреса на функцията. Това е основното използване на указатели на функции.

Заключение

Това е всичко за указателите, техните дефиниции и употреби в C ++.

В следващия урок ще научим повече за препратките в C ++. Препратките също имат специална употреба в C ++ и често се използват като псевдоними за променливи.

=> Щракнете тук за абсолютната серия за обучение на C ++.

Препоръчително четене

^