Указатели C++ с примерами

Что такое указатели?

В C++ указатель ссылается на переменную, которая содержит адрес другой переменной. Как и обычные переменные, указатели имеют тип данных. Например, указатель типа integer может содержать адрес переменной типа integer. Указатель символьного типа может содержать адрес переменной символьного типа.

Вы должны видеть указатель как символическое представление адреса памяти. С помощью указателей программы могут имитировать вызов по ссылке. Они также могут создавать и управлять динамическими структурами данных. В C++ переменная-указатель относится к переменной, указывающей на определенный адрес в памяти, на который указывает другая переменная.

Из этого руководства по C++ вы узнаете:

• Что такое указатели?
• Адреса на C++
• Синтаксис объявления указателя
• Оператор ссылки (&) и оператор сравнения (*)
• Указатели и массивы
• Указатель NULL
• Указатели переменных
• Применение указателей
• Преимущества использования указателей

Адреса на C++

Чтобы понять указатели C++, вы должны понимать, как компьютеры хранят данные.

Когда вы создаете переменную в своей программе на C++, ей выделяется некоторый объем памяти компьютера. Значение этой переменной сохраняется в назначенном месте.

Чтобы узнать место в памяти компьютера, где хранятся данные, C++ предоставляет & (ссылочный) оператор. Оператор возвращает адрес, который занимает переменная.

Например, если x является переменной, &x возвращает адрес переменной.

Синтаксис объявления указателя

Объявление C++ имеет следующий синтаксис:

datatype *variable_name; 

• Тип данных — это базовый тип указателя, который должен быть допустимым типом данных C++.
• Имя_переменной должно быть именем переменной-указателя.
• Звездочка, использованная выше для объявления указателя, аналогична звездочке, используемой для выполнения операции умножения. Это звездочка, которая помечает переменную как указатель.

Вот пример правильных объявлений указателей в C++:

int    *x;    // a pointer to integer
double *x;    // a pointer to double
float  *x;    // a pointer to float
char   *ch     // a pointer to a character

Оператор ссылки (&) и оператор сравнения (*)

Оператор ссылки (&) возвращает адрес переменной.

Оператор разыменования (*) помогает нам получить значение, которое было сохранено в адресе памяти.

Например:

Если у нас есть переменная с именем num, хранящаяся по адресу 0x234 и хранящая значение 28.

Оператор ссылки (&) вернет 0x234.

Оператор разыменования (*) вернет 5.

Пример 1:

#include <iostream>
using namespace std;
int main() {
	int  x = 27;  
	int  *ip;        
	ip = &x;       
	cout << "Value of x is : ";
	cout << x << endl;
	cout << "Value of ip is : ";
	cout << ip<< endl;
	cout << "Value of *ip is : ";
	cout << *ip << endl;
	return 0;
}

Вывод:

Как это работает:

Вот скриншот кода:

Пояснение кода:

1. Импортируйте файл заголовка iostream. Это позволит нам использовать функции, определенные в заголовочном файле, без ошибок.
2. Включите пространство имен std, чтобы использовать его классы, не вызывая его.
3. Вызовите функцию main(). Логика программы должна быть добавлена ​​в тело этой функции. { отмечает начало тела функции.
4. Объявите целочисленную переменную x и присвойте ей значение 27.
5. Объявите переменную-указатель *ip.
6. Сохраните адрес переменной x в переменной-указателе.
7. Выведите текст на консоль.
8. Выведите значение переменной x на экран.
9. Выведите текст на консоль.
10. Выведите адрес переменной x. Значение адреса хранилось в переменной ip.
11. Выведите текст на консоль.
12. Распечатать значение, хранящееся по адресу указателя.
13. При успешном выполнении программа должна возвращать значение.
14. Конец тела функции main().

Указатели и массивы

Массивы и указатели работают на основе связанной концепции. При работе с массивами, имеющими указатели, следует учитывать разные вещи. Само имя массива обозначает базовый адрес массива. Это означает, что для присвоения адреса массива указателю не следует использовать амперсанд (&).

Например:

p = arr;

Вышеупомянутое верно, поскольку arr представляет адрес массива. Вот еще один пример:

p = &arr;

Вышеприведенное неверно.

Мы можем неявно преобразовать массив в указатель. Например:

int arr [20];
int * ip;

Ниже приведена допустимая операция:

ip = arr;

После приведенного выше объявления ip и arr будут эквивалентны, и у них будут общие свойства. Однако на ip можно назначить другой адрес, а на arr мы ничего не можем назначить.

Пример 2:

В этом примере показано, как перемещаться по массиву с помощью указателей:

#include <iostream>
using namespace std;
int main() {
	int *ip;
	int arr[] = { 10, 34, 13, 76, 5, 46 };
	ip = arr;
	for (int x = 0; x < 6; x++) {
		cout << *ip << endl;
		ip++;
	}
	return 0;
}

Вывод:

Вот скриншот кода:

Пояснение кода:

1. Объявите целочисленную переменную-указатель ip.
2. Объявите массив с именем arr и сохраните в нем 6 целых чисел.
3. Назначить arr для ip. IP и arr станут эквивалентными.
4. Создайте цикл for. Переменная цикла x была создана для перебора элементов массива с индексом от 0 до 5.
5. Распечатать значения, хранящиеся по адресу IP указателя. За одну итерацию будет возвращено одно значение, всего будет выполнено 6 повторений. Endl — это ключевое слово C++, означающее конечную строку. Это действие позволяет перемещать курсор на следующую строку после печати каждого значения. Каждое значение будет напечатано в отдельной строке.
6. Для перемещения указателя на следующую позицию int после каждой итерации.
7. Конец цикла for.
8. При успешном выполнении программа должна что-то вернуть.
9. Конец тела функции main().

НУЛЕВОЙ указатель

Если нет точного адреса, который должен быть назначен, то переменной указателя может быть присвоено значение NULL. Это нужно сделать во время декларации. Такой указатель называется нулевым указателем. Его значение равно нулю и определено во многих стандартных библиотеках, таких как iostream.

Пример 3:

#include <iostream>
using namespace std;
int main() {
	int  *ip = NULL;
	cout << "Value of ip is: " << ip;
	return 0;
}

Вывод:

Вот скриншот кода:

Пояснение кода:

1. Объявите переменную-указатель ip и присвойте ей значение NULL.
2. Вывести значение переменной-указателя ip рядом с текстом на консоли.
3. Программа должна возвращать значение после успешного завершения.
4. Конец тела функции main().

Указатели переменных

С C++ вы можете манипулировать данными прямо из памяти компьютера.

Пространство памяти может быть назначено или переназначено по желанию. Это стало возможным благодаря переменным Pointer.

Переменные-указатели указывают на определенный адрес в памяти компьютера, на который указывает другая переменная.

Его можно объявить следующим образом:

int *p;

Или,

int* p;

В примере с вами мы объявили переменную-указатель p.

Он будет содержать адрес памяти.

Звездочка — это оператор разыменования, означающий указатель на.

Указатель p указывает на целочисленное значение в адресе памяти.

Пример 4:

#include <iostream>

using namespace std;
int main() {
	int *p, x = 30;
	p = &x;
	cout << "Value of x is: " << *p;
	return 0;
}

Вывод:

<сильный>

Вот скриншот кода:

Пояснение кода:

1. Объявите переменную-указатель p и переменную x со значением 30.
2. Присвоить адрес переменной x переменной p.
3. Выведите значение переменной-указателя p рядом с текстом на консоли.
4. Программа должна возвращать значение после успешного завершения.
5. Конец тела функции main().

Применение указателей

Функции в C++ могут возвращать только одно значение. Кроме того, все переменные, объявленные в функции, размещаются в стеке вызова функции. Как только функция возвращается, все переменные стека уничтожаются.

Аргументы в функцию передаются по значению, и любое изменение, выполненное с переменными, не меняет значения фактических переданных переменных. Следующий пример помогает проиллюстрировать эту концепцию:-

Пример 5:

#include <iostream>

using namespace std;
void test(int*, int*);
int main() {
	int a = 5, b = 5;
	cout << "Before changing:" << endl;
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	test(&a, &b);

	cout << "\nAfter changing" << endl;
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	return 0;
}

void test(int* n1, int* n2) {
	*n1 = 10;
	*n2 = 11;
}

Вывод:

<сильный>

Вот скриншот кода:

<сильный>

Пояснение кода:

1. Создайте прототип функции с именем test, которая будет принимать два целочисленных параметра.
2. Вызовите функцию main(). Мы добавим логику программы внутрь ее тела.
3. Объявите две целочисленные переменные a и b, каждая со значением 5.
4. Выведите текст на консоль. Endl (конечная строка) переместит курсор, чтобы начать печать в следующей строке.
5. Выведите значение переменной a на консоль вместе с другим текстом. Endl (конечная строка) переместит курсор, чтобы начать печать в следующей строке.
6. Выведите значение переменной b на консоль вместе с другим текстом. Endl (конечная строка) переместит курсор, чтобы начать печать в следующей строке.
7. Создайте функцию с именем test(), которая принимает в качестве параметров адреса переменных a и b.
8. Выведите текст на консоль. \n создаст новую пустую строку перед печатью текста. Endl (конечная строка) переместит курсор, чтобы начать печать в следующей строке после печати текста.
9. Выведите значение переменной a на консоль вместе с другим текстом. Endl (конечная строка) переместит курсор, чтобы начать печать в следующей строке.
10. Выведите значение переменной b на консоль вместе с другим текстом. Endl (конечная строка) переместит курсор, чтобы начать печать в следующей строке.
11. Программа должна возвращать значение после успешного завершения.
12. Конец тела функции main().
13. Определение функции test(). Функция должна принимать две целочисленные переменные-указатели *n1 и *n2.
14. Присвоение переменной указателя *n1 значения 10.
15. Присвоение переменной указателя *n2 значения 11.
16. Конец тела функции test().

Несмотря на то, что новые значения присваиваются переменным a и b внутри проверки функции, после завершения вызова функции то же самое не отражается во внешней функции main.

Использование указателей в качестве аргументов функции помогает передать фактический адрес переменной в функцию, и все изменения, выполненные с переменной, будут отражены во внешней функции.

В приведенном выше случае функция «тест» имеет адрес переменных «а» и «б». Эти две переменные напрямую доступны из функции «тест», и, следовательно, любые изменения, внесенные в эти переменные, отражаются в вызывающей функции. 'основной'

Преимущества использования указателей

Вот плюсы/преимущества использования указателей

• Указатели — это переменные, в которых хранятся адреса других переменных в C++.
• Функция может изменять и возвращать более одной переменной с помощью указателей.
• Память можно динамически выделять и освобождать с помощью указателей.
• Указатели помогают упростить программу.
• Скорость выполнения программы повышается при использовании указателей.

Обзор:

• Указатель ссылается на переменную, содержащую адрес другой переменной.
• Каждый указатель имеет допустимый тип данных.
• Указатель — это символическое представление адреса памяти.
• Указатели позволяют программам имитировать вызов по ссылке, а также создавать динамические структуры данных и управлять ими.
• Массивы и указатели используют родственную концепцию.
• Имя массива обозначает базу массива.
• Если вы хотите присвоить адрес массива указателю, не используйте амперсанд (&).
• Если нет конкретного адреса для назначения переменной указателя, присвойте ей значение NULL.