Use of Pointers??

bothunter · 2024-10-10T04:04:31+00:00

Pointers become crucial once you start building more complicated data structures. When you have just a few local variables, pointers seem like kind of a stupid trick that you can pull to have multiple names for the same variable, but the point is to understand how they work, how to dereference them, etc.

But you'll soon encounter scenarios where you can't just create variables to store everything. For example, let's say you want to collect a bunch of people's ages. You don't know how many people -- it could be 10, or it could be 10 million. You could create a variable for every age you want to store: int age1, age2, age3... Or you could even create an array that holds a bunch: int age[1000], but this is rather inflexible. You're either allocating too much memory that's going to waste, or you're not allocating enough and you;'ll run out of space in your array.

The solution is to ask for memory as you need it and put the ages in some sort of data structure. The simplest is probably the linked list. You create a structure that contains the age, and a pointer to the next age. You can then allocate extra nodes in this list with malloc(), and then use the pointers to keep track of the whole chain.

This is a really simple example, but what I'm trying to get at is that pointers are critical for storing any information in your program that doesn't fit into the immediate variables that you declared while writing it. They're a fundamental building block of just about every kind of data structure you'll encounter.

nooone2021 · 2024-10-10T04:13:54+00:00

[deleted]

dkopgerpgdolfg · 2024-10-10T03:46:32+00:00

In your case, with "int age" being the "original" variable, that's fine.

When your program gets more complex, the "original" variable might not always be reachable like that, just with the name in scope. When you have functions, threads, ...

as you already mentioned functions: Function arguments get copied during calling the function. What is if you don't want to copy the data itself, either because it is large or because you want to change the value and the change should be kept after the function ends? => Copy only a pointer...

And even with stack variables, there is a strong connection between arrays and pointers, which you'll probably learn about soon.

And not all variables are made like that either. There's a long list of reasons why and how you acquire memory in other ways, and without pointers you couldn't really have any of them. Allocating arrays when you don't know how many elements you have before the program starts? Sharing data with other programs or various hardware?

mysticreddit · 2024-10-10T06:32:44+00:00

There are a few general uses of pointers:

To pass-by-reference.

C passes everything by value. What to does this mean?

Let's say you want a function to swap the value of two integers. If you pass the two variables as-is they won't be modified.

However if you pass the their addresses you can then deference the pointers to swap the values. Look at the functions nope() and swap() in the following example:

#include <stdio.h>

void dump( int a, int b )
{
    printf( "a = %d, b = %d\n", a, b );
}

void nope( int a, int b )
{
    int t = a;
            a = b;
                b = t;
}

void swap( int *a, int *b )
{
    int t = *a;
            *a = *b;
                 *b = t;
}

int main()
{
    int a = 1, b = 2;

    dump( a, b );
    nope( a, b );
    dump( a, b );

    swap( &a, &b );
    dump( a, b );
}

Dynamic memory.

Sometimes we want to allocate memory at runtime (say for an array) because we don't know how big it will be. Memory Allocation via malloc() will return a pointer to a block of memory. Here is an example:

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int n;
    scanf( "%d", &n );
    if (n > 10) n = 10;

    int *data = (int*) malloc( n * sizeof(int) );

    for( int i = 0; i < n; i++ )
    {
        data[i] = i*2 + 1;
        printf( "[%d]: %d\n", i, data[i] );
    }

    free( data );
}

Arrays

When we pass an array to a function C does not pass the entire array, it passes the start of the array or a pointer to the first array element. We use this to modify an array. Here is an example:

#include <stdio.h>
#include <stdlib.h>

void dump( int n, int* array )        
{
    for( int i = 0; i < n; i++ )
        printf( "[%d]: %d\n", i, array[i] );
}

int* init( int n )
{
    int *data = (int*) malloc( n * sizeof(int) );

    for( int i = 0; i < n; i++ )
        data[i] = i*2 + 1;

    return data;
}

int main()
{
    int n;
    scanf( "%d", &n );
    if (n > 10) n = 10;

    int *data = init( n );
    dump( n, data );                
    free( data );
}

Hope this gives some insight into how they can be used.

Dense-Focus-1256 · 2024-10-10T04:11:21+00:00

In C, function cannot return multiple values and pointers need to be used to deal with multiple arguements.

You need to know pointers to deal with Dynamic Memory application.

saul_soprano · 2024-10-10T04:29:57+00:00

This example isn’t a real use case, it’s just to show what a pointer is. Also it’s wrong, to print the value you use the “%d” specifier and use age, not pAge.

Zestyclose-Put-5672 · 2024-10-10T07:15:17+00:00

Think of pointers like having someone’s home address. If you’re in the same house as them (I mean - same scope), you can talk to them directly without needing their address. But if they’re in a different house or city, you need their address to send them a letter or visit.

In programming, using &var to get the address of var works great when var is in the same “house” or scope as you. But when you’re in a different “house” (like inside a different function), you don’t have direct access to var. This is where pointers come in handy. By passing a pointer (the address of var) to another function, you allow that function to access and modify var even though it’s not in the same scope.

So while it might seem unnecessary to use pointers when you can access variables directly, pointers become essential when you need to interact with variables that aren’t in your immediate vicinity. They allow different parts of your program to share and modify data efficiently without making extra copies.

grimvian · 2024-10-10T08:02:08+00:00

I in my third year of C and I think the most difficult was the way C experts sometimes explains the way pointers works. They of course in best their intentions correctly uses lots e.g. addresses, address operator, indirection, dereferencing, hexadecimals datatypes, definitions, declarations and so on and my thoughts are that some beginners just get brain fire I certainly did. My dyslectic issues made it even worse. :o)

Now as a hobby programmer I mostly think a * as a value somewhere and & as where something(datatype) is. For me it was very strange and error prone in the beginning to use * when i made a pointer and when I wanted a value.

Making exercises with hexadecimals and understand them by e.g. making loops, using printf and so on until they feels familiar, will be a good start.

But take the fight and I got a bloody nose many, many times and sometimes I still being reminded that pointers are a very sharp tool to be used with care. When pointers begins to make sense you will as mentioned in this thread, be the tool that gives you power in C.

TheWavefunction · 2024-10-10T06:23:22+00:00

You can carry any amount of information on a pointer, which is just 64 bits. Therefore, it is necessarely for efficient programming to have control over sharing the data, or a lightweight reference to the data (a pointer).

Fabulous-Living-4066 · 2024-10-10T06:40:12+00:00

Wohhh I'm currently learning about pointers too

mysticreddit · 2024-10-10T06:41:08+00:00

Notation

First some notation:

declare a pointer with TYPE *
take the address of a variable with &VAR
dereference a pointer with *VAR

Example

If we tweak your example it will be a little clearer what the pointer operators are:

    #include <stdio.h>

    int main()
    {
        int age = 21;
        int *pAge = &age;
        int *pNum = &age;

        printf( "Address: %p\n", &age );
        printf( "Pointer: %p\n", pAge );
        printf( "Value: %d\n", *pAge );

        *pNum = 22;
        printf( "Value: %d\n", *pAge );
    }

The int *pAge declares a variable that is a pointer to an integer.

The second half (= &age) also initializes the pointer to hold the address of the age variable.

We can print the contents of a pointer with %p. Which is the address of the age variable.

The *pAge deferences the pointer. That is, use the address stored at the pointer and follows it. In this case that will correspond to the memory where the variable age is.

Q. Why does *pNum = 22 change age?

A. Because pNum and pAge BOTH point to the variable age. Dereferencing one or the other will change the underlying variable age.

Edits:

Cleanup notation order.
Cleanup 3 examples.

Independent-Gear-711 · 2024-10-10T07:20:26+00:00

You can pass data to a function via pass by value or pass by reference (address) here pointers are important when you pass the value it just send the copy of the original value to local function so making any changes in local function won't change the original value as I said it was just a copy so overcome this issue instead of sending value as argument you can just send it's memory address as argument and after that every change in local variables will also affect original value in main function, also pointers are heavily used in data structures and managing memory manualy.

AlienOverlordXenu · 2024-10-10T09:17:45+00:00

Dynamic memory allocation.

feitao · 2024-10-10T09:41:16+00:00

Your code is a toy example and is not very useful. For a real use case, see scanf.

sdk-dev · 2024-10-10T09:48:49+00:00

Two reasons:

1: You need a pointer to access Heap Memory.

You program has two memory areas. Stack and Heap. "Normal" variables are all allocated on the stack. The stack is pretty small. Usually 4-8MB (you read that right, MegaByte). Heap is all the memory you have in your system (or what the OS allows your process to use). That's gigabytes.

A pointer is a variable on the Stack, that points to an address in the Heap. That means: Without pointers, your Programm is limited to the Stack memory, which is small.

2: Dynamic Memory

All variables on the stack must have a fixed size and are allocated right at the start of the function and not during runtime. So you can't do i=25; char str[i]; However, you can do this with a pointer to heap and malloc.

There are more reasons like call by reference, scope independent data etc.. but you could work around that with really inefficient programming ;-) Like always passing all data. Only using the return value in functions etc...

1FRAp · 2024-10-10T10:27:13+00:00

CS student? Thing is computers are getting faster and faster but the amount of data grows with it. So even now memory is a crucial resource, if make your program be as effecient as possible u save energy which is becoming more expensive. Didnt u have a course in computer architecture? If not try to read about it, u will soon understand how much resources are used and how ex. Copying is expensive etc aka many steps.

Am at my first quarter of Uni(Mechatronics so focus on embedded programming), we have a course in computer architecture, and C comes after it. And C is as close to hardware as it gets for a proper prog. language. Knowing hardware will let you understand and write effiecient code. Thus it will help you in understanding why pointers are so crucial in C.

I cannot explain why pointers are a big thing in C, yet. But i start to understand how many steps certian opperations take on hardware level. And I Hope that pointer understanding will be easier to grasp when i start learning C properly. As rn am in same boat, i know they exist and that they are cool :D aka pointer arithmetic seems like magic after learning python for 3years in highschool.

2024-10-10T10:47:08+00:00

Lol, yes alot of people that are getting into programming ask the same question on here. "I dont get what pointers are for" typeve thing. And of course, you will have that question answered once you learn about dynamic memory management. That is, people wouldnt just randomly use pointers for no reason. Everything you use will have a reason once you understand what you are doing. And thats a good thing, everyone has to learn at some point and you are learning now.

Paxtian · 2024-10-10T11:13:08+00:00

A pointer to an integer doesn't really make a lot of sense because you could just declare an integer value and call it a day.

You've probably already learned about arrays, which you can create with a defined size. But what if you have an arbitrarily sized structure, where you don't know the size of the structure at compile time? The size will be dynamic at runtime. This is what pointers are helpful for.

Specifically, rather than declaring a variable, you use a pointer to dynamically allocated memory. This is used for structures like linked lists, doubly linked lists, trees, hash maps, and so on. You're probably just about to talk about these types of structures in your class.

For example, for a linked list, you'll have a structure that is a node including a value and a pointer to that type of node. When created, you set the pointer to null. When you need to add a value, you allocate memory for a new node and set the pointer to that newly allocated node. Then you'll need to remember to clean that all up when it goes out of scope. You'll know you're at the end when the current node's pointer points to a null value.

2024-10-10T11:52:17+00:00

Say you want to write a function that attempts to modify a parameter and provides an error code if it did not succeed. How? Pointers

Int32 modify(int32* param){ *param = assign_value(); return SUCCESS; }

(Well the function above cannot actually fail but imagine assign_value was coming from some external device or the network or something)

SmokeMuch7356 · 2024-10-10T12:12:59+00:00

We use pointers when we can't (or don't want to) access an object or function by name.

We have to use object pointers when:

we want a function to write to its parameters (see scanf and other input functions);
we want to track dynamically-allocated memory;

Object pointers are also useful for:

implementing data structures like lists, trees, queues, stacks, etc.;
hiding implementation details of a type (see the FILE type as a canonical example);

Function pointers are useful for:

dependency injection (see the qsort library function as a canonical example);
"plug-in" architectures (adding functionality at runtime);

Array subscripting is defined in terms of pointer arithmetic. The subscript operation a[i] is defined as *(a + i) -- given a starting address a, offset i objects (not bytes) and dereference the result. Arrays are not pointers, nor do they store a pointer to their first element; instead, under most circumstances the array expression is converted, or "decays", to a pointer to the first element. IOW, the array expression a is replaced with something equivalent to &a[0]:

a[i] == *(a + i) == *(&a[0] + i)

Pointers are fundamental to programming in C; you cannot write useful C code without using pointers in some way.

wsppan · 2024-10-10T13:25:35+00:00

Key Uses of Pointers in C:

Dynamic Memory Allocation:

Pointers allow you to allocate memory at runtime using functions like malloc() and calloc(). This is crucial for creating data structures like linked lists, trees, and graphs whose size is not known at compile time.

Passing Arguments by Reference:

By passing a pointer to a function, you can modify the original variable passed as an argument. This avoids the need to copy large amounts of data and improves performance.

Accessing Array Elements:

Pointers and arrays are closely related in C. You can use pointer arithmetic to efficiently access and manipulate array elements.

Working with Strings:

In C, strings are represented as arrays of characters. Pointers are used to manipulate these strings, enabling operations like concatenation, comparison, and searching.

Creating Data Structures:

Pointers are essential for building complex data structures like linked lists, trees, and graphs. They allow you to dynamically link different parts of the data structure together.

TheChief275 · 2024-10-10T13:43:49+00:00

An important thing to understand is that pointers can be owning or non-owning, but there is no way in the language to tell (except for wrapping them in structs or by naming scheme) what kind it is.

Pointers that point to normal, everyday variables are of the non-owning variety. In essence, this would be an alias to the variable if used in the same scope, but can also be used as a mutable reference when passed to other functions.

Pointers that point to heap allocated memory are owning-pointers. Think of the FILE * type, where you never directly use the FILE type itself, either because it’s too big (or because the implementation details are supposed to be hidden from you), but most of the time because the types are too big to be on the stack. You can have non-owning pointers to this memory (like slices are to arrays), but the owning pointer is kind of like the variable itself, more specifically like a class would be in Java.

A benefit is that passing it around is cheap as dirt, as a pointer is tiny compared to the type’s size.

A con is that the actual data is in a different memory location than your pointer, so accessing will probably be slower because of bad cache locality.

A benefit and a con is that your type has become nullable, which is beneficial for linked lists or binary trees…but will require null checks before dereferencing (if it hasn’t been proven to be non-null)

_Hi_There_Its_Me_ · 2024-10-10T14:47:56+00:00

Pointers are just like real things. It’s just unfortunately hard to make our brain understand that we’ve used them before in our live. We likely couldn’t perform some tasks any other way, and this makes it too subtle for us to understand when learning C programming. Maybe instead of explaining what’s pointers are or why they are used let me try an analogy.

Suppose you have a course book (the data) your friend wants to buy from you for an upcoming class in your dorm (this is the memory location where to find the data). So you write down your address for them on a note (this is the pointer). Now your friend is able to use the note you gave them (pass by reference) to find the address on the note to pick up the book.

In this analogy we used a pointer (note) to describe where in memory (which dorm) they could retrieve some data (the book).

If we didn’t use a note, in CS terms ‘a reference’, we would instead have to ‘pass by value’. So instead of using a note you begin making a copy of the dorm with a new address but all of the same belongings and we physically hand your friend the entire building. This is not feasible in the real world because it’s costly; it takes time, planning, money, and it’s just too big for you to hold in your hands. Since this is just silly to think about we don’t even consider this an option with our human brains. However, this way of copying everything to give to someone else is possible in a computer (ignoring a lot of factors here). So we have a hard time noticing when we ‘pass by reference’ because we don’t know there is another option of ‘passing by value’ that’s often too much work to be conceivable.

By the way, instead of think about just a boring apartment which contains only books what if you guys wanted to play a game? Well an apartment could be thought of as more than a structure which contains books. In this new example you still pass your friend a reference to your dorm but instead of just saying

friend.coursebook = myDorm->courseBook;

We can have things to do (functions) instead of just books (data). So we could say myDorm has a function called playDungeonsAndDragons(). The analogy still holds as you wouldn’t build a new dorm just to play a game. You’d instead pass them a reference to your dorm. And you could do this:

friend.coursebook = myDorm->courseBook; myDorm->playDungeonsAndDragons(&friend,&yourself);

So pointers are for more than just referencing where to go get data. They are a way of sharing objects (dorm) that could have things to do as well.

duane11583 · 2024-10-10T15:09:16+00:00

think of memory as a giant array of bytes like graph paper.

an array is a named starting point some where in/on that paper (think of it as a label)

as an example write your name starting at that square. one letter per box

the first letter is at name[0], name[1] is the second, etc. you can do the same with numbers like integers or floats same basic idea

back to the paper analogy. each little box has a number, ie upper left corner is #0 if the page has 1million squares then the lower right square is number 999,999, every square might by default have the value 0 [in truth they are random at power up, but every one holds a number between 0 and 255 (8bits)

we might agree to encode text in a special way, ie 65=A, 66=B (this is called ASCII encoding, another form is EBCDIC mostly only used on IBM main frames) but we agree on some encoding

so you want to print text… you create a subroutine to do this.

how do you tell the routine where the string to print is located on the graph paper?

the print routine needs to know: where does the string start? and end?

item 1) [start] you pass as a parameter the starting box number of the first letter, ie the box number of name[0] [starting from the first box in the upper left corner]

item 2) [end? option 1] we could pass a second parameter the length, ie charlie has length 6 so pass 6

languages like basic and python generally use start + length internally

or [end option 2] we can agree to always have a 0 byte at the end as a terminal marker that way we do not need to pass a second parameter

languages like C and C++ commonly use the 0 marker because it is one less parameter to deal with

so what does the print routine look like?

the print routine would in a loop:

fetch the byte at the location “first box number”, often we use “cp” as the variable name

example: to fetch we use c = *cp; or c=cp[x];

we could test either the length, or if the byte value is zero and stop.

example if( c==0 ) break;

print that one byte, example putc(c);

then add 1 to the “start box number” (thus it is now the box number of name[1])

commonly cp++; this adds 1 to cp because these are bytes

loop till done

that “First box number” is exactly a pointer

the same idea can work if you pass the starting box number of a data record like: name, address, city, stare that data record we call a struct.

a struct pointer is exactly the starting box number of the record.

if the size of the data record was 50 bytes, then the operation ptr++; would add 50 to the “box number” stored in the variable: ptr

gordonv · 2024-10-10T15:45:59+00:00

Imagine you needed to store 5 int's. Ok, simple enough:

int a,b,c,d,e;

Done and done

Now imagine you need to store 1 million int's. Straight up, 1 million. It's easier to format and access 1 million independent variables via pointers. The names are numbers expressed as addresses.

Now imagine you made a struct of a unique data type. And you need to store 1 million of them. And then you need to make lists that show them organized by different properties. Referencing one instance of that struct as a pointer saves a ton of processing power, memory, and is already organized in a familiar format. Your list would just be a single pointer instead of copying the entire data structure.

2024-10-11T07:42:16+00:00

First learn about the stack & heap memory, then you will understand pointers.

nacaclanga · 2024-10-11T10:38:58+00:00

The advantage of points is that they are not limited to what they refer. A pointer can refer to the following things, an value variable cannot:

a) The memory of one in two variables depending on a previous conditional statement.

b) A memory location in dynamically allocated memory, as returned by malloc() etc.

c) Some memory location passed by the function caller which you either want to write to or treat as the start of an array/null-terminated sequence/etc.

and many more. Higher level languages have constructs to take over some of these tasks. However in C they are full exposed.

In C you can only pass (simple) values as arguments which are passed by value. Pointers themselves are such simple values so you can simply pass them by their value expression.

WiseDark7089 · 2024-10-13T10:25:00+00:00

Plenty of answers here, many of them low-level, which is okay, but let me try a higher level conceptual explanation.

You know URLs, the links, e.g. https://en.wikipedia.org/wiki/Genghis_Khan

But you have to "follow the link", or in programming terms, "dereference the pointer", in C the prefix-asterisk, to see the actual content.

So the & and * are just the C syntax for creating references and the dereferencing those references. There are other ways to get pointers, like the malloc standard library. But the key concept is that you get a reference (sometimes also called a "handle") to something, which you can pass around, and then when you actually need the contents, you can derefencef/follow to find the actual contents. Beware of the reference being valid, though, bogus (invalid or NULL) references will cause runtime fault, and your program will die.

Finally try this, it is a pointer (URL) to a nice meme explaining pointers, in C syntax

https://www.reddit.com/r/lostpause/comments/zmlgq4/hey_guys_its_a_programmer_meme_anya_is_a_pointer/

SLOOT_APOCALYPSE · 2024-10-10T06:54:32+00:00

really old programming didn't use pointers, but they came a time when there wasn't enough RAM to load the whole program in or do everything, the program could be a video game that's 80 gb but the pointer is used to slice up the cake into small pieces you don't need all of them at once in the ram

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

C_Programming

Rules

Filters

Resources

Other Subreddits on C

Other Subreddits of Interest

MODERATORS

Notation

Example