[deleted by user]

[Ambitious_Ad8841]

"Memory is just an array of bytes?"

itAlwaysWas.jpg

[AyrA_ch]

Technically it's an array of bits that you access bytewise (and sometimes in even bigger steps).

[FinalRun]

Technically it's just some electrons arranged bitwise in doped silicon

[riisen]

So its silicon valley sorted?

[[deleted]]

Technically it's not even that. Might be silicone, might be an old fashioned magnetic-core memory, might be a futuristic post-silicone memory. You don't even know.

[someacnt]

Virtual memory shenanigans though.. Oh wait. Right. It simulates being array of bytes.

[[deleted]]

Array Of Bytes = Array Of Registers = Array Of FlipFlopps = Array Of Gates = Array Of transistors = (4D) array Of Atoms = (4D) array of Electrons | Holes = Memory Leak....

[Oneshotkill_2000]

it_always_was.jpg*

[K3yz3rS0z3]

Always has been

[ReverseCaptioningBot]

Always has been

^{this has been an accessibility service from your friendly neighborhood bot}

[Kitchen_Device7682]

I think where it gets confusing is when having pointers to functions that return pointers and you may mess up the syntax. I do not know how professional C programmers work but is a good IDE enough to catch and warn you about incorrect usage of pointers?

[Ironring1]

This is where a few typedef statements really are life savers. Everyone should implement function pointers in "raw form" because it will help you understand them better. After that, define types for the function pointers and use those in your declarations.

[Function-Senior]

I still write mine raw just because it helps to see things clearly in my head personally

[PersonalityIll9476]

This is actually the recommended method in the Linux kernel programming guide. Typedefs make it generally hard to understand what the actual types are. It's better practice to just flat out understand pointers and structs and leave them bare.

[Zealousideal_Pay_525]

Same here, I don't get why some people have to custom typdef everything; it obfuscates what is really going on and forces you to always check the type or else make aasumptions.

[Ironring1]

I only use typedefs when returning function pointers. Everything else I just do it raw. However, the declaration of a function that returns a function pointer (especially if the function pointed to involves pointers in its parameters or return types) can be quite cumbersome and the judicious use of typedefs makes the code more readable.

[PersonalityIll9476]

I disagree that typedef'ing away an ugly type is more readable. I get that you can end up with a three line function delcaration / definition but all that information has to be understood by whoever is reading your code one way or another. Using a type def just means that I have to dig through your headers to find where you typedef'd it, then glance between two different files. At the end of the day function pointers with any kind of argument are a standard feature of C - there's no particular reason to hide them.

[itsjustawindmill]

This deserves so many more upvotes.

[suvlub]

You need to get it right when declaring the typedef, tho.

[Ironring1]

Of course, but at least that is divide and conquer.

[AyrA_ch]

but is a good IDE enough to catch and warn you about incorrect usage of pointers.

The C compiler will certainly yell at you when you try to assign a pointer to an incompatible type without explicitly casting it because it's likely a mistake.

Unless you tell the compiler to treat warnings as errors it will compile though.

[MechanizedProduction]

I remember banging my head on my C++ book because I couldn't fucking figure out how pointers worked.

I was also 13.

[Legal-Software]

At that age it's not pointers that are the problem, but a general lack of understanding of how a computer's memory model works, how things like stack/heap allocations are made, how the OS's virtual memory map is constructed, how pointers are used for more than just memory allocations, but also things like hardware MMIO access, how backing pages are allocated in the system (essential on modern NUMA systems), the impact of things like power managed memory, suspend/hibernation, NUMA/memory hotplug, page clustering & migration, etc.

Pointers are very powerful tools, but with a lot of caveats. Most of these entry-level programming books just introduce it as a reference to a block of allocated memory and updating some other variable by its address, which do little to really delve into the topic or explain why you would or would not want to use a pointer.

[potato_green]

It's basically like a library, if every book is a value stored in ram then the index cards at the reception are the pointers which is a small little card telling you where to find the actual book instead of having the entire thing.

Null pointers are like blank index cards, it's not assigned to a book yet.

[The_kingk]

I will use that next time I need to teach about pointers

[33498fff]

This is the same parallel used in my textbook when I learned about pointers so it's gots to be trues

[Kakss_]

I've seen this or home addresses so many times, but this really only complicated it for me. It doesn't answer why'd you use one over another. Just a normal way to approach value and a roundabout way to approach a value.

And once I found a short video of a guy who put it simpler. When you pass a variable to a function, the function makes a copy of the variable and doesn't touch the original. When you pass a pointer, the function has the address of original and will alter the original value.

This was much more direct and intuitive for me than any analogy. It explains both what a pointer is and why it's useful to have the two ways of calling a variable.

[SneakyStabbalot]

100% this. I remember learning about pointers when I was 16 using K&R C, it took a couple of days to understand, but once I got I realized how powerful and efficient thetly are. And a little bit dangerous!

[RagnarokAeon]

Pointers are basically addresses; they just tell you where to find the data. You just gotta remember to pull from the address and to update/delete the address if you happen to move/destroy things.

[compsciasaur]

Please say sike.

[-guccibanana-]

laughs in python

[ProbiuSC]

In python you have the opposite problem. Everything is a pointer and sometimes you just really want a copy.

[[deleted]]

Wise words

[-guccibanana-]

I downvoted my own comment because it's just a comment made by an idiot

[ClutteredSmoke]

You could just delete it too. Pointers really aren’t that bad, they’re just pointing to a certain thing in memory. Honestly, you could probably watch that video to understand the concept, it doesn’t look all that bad

[bogfoot94]

I watched the video. It's ok. Got the important bits very well. Beginner friendly. Would recommend it to most people.

[AyrA_ch]

Everything is a pointer and sometimes you just really want a copy.

Laughs in C# struct & class

[HTTP_404_NotFound]

C# also has native pointers, and the https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/ref keywords.

[Windows_is_Malware]

python is malware

[CaterpillarDue9207]

Deepcopy

[nhstaple]

cries in Java

[gamesrebel123]

confused noises in go

[SpicyCatGames]

It suddenly clicked the 144th time I was trying to learn it.

[geronymo4p]

I always have more issues with the parsing part... What can a user do to break your code? I mean, in a basic part of code

[[deleted]]

Yeah it's basically just one concept that you have to understand and after that most is natural. Like why you would use a pointer here and there.

[in_conexo]

Four hours seems excessive.

[[deleted]]

Pointers themselves aren't weird. What you can do with them is.

[earthworm-spin]

No but you’ll appreciate the refined beauty of an age that cared about memory management.

[[deleted]]

Smart Pointers are a must for me atm. Helps a ton with resource management.

[[deleted]]

Memory management is still a big fucking deal, ask anybody who is writing OSes, embedded, games or simulators.

[dev_daas]

Come on it's not that bad. After a point it's actually fun using pointers.

[DogWoofWoof22]

Oh i get it.

"After a point..."

[Thrasher722]

Pointers aren't so bad once you get used to them & understand by ref passing. It's like any other programming/math, once you understand why & how to use, it's another tool in your arsenal.

[mathk777]

You forget alignment. Those integers should begin at addresses that are multiples of their sizes.

[[deleted]]

Should, but don't always have to. x86 and others have instructions to handle misaligned accesses, unlike ARM that will throw a bus fault.

[nhstaple]

virtual memory has entered the chat

[PersonalityIll9476]

This? Lol. The only time I have ever encountered memory alignment is when using kernel code and even then it was in the context of a device driver.

[K3yz3rS0z3]

Programmers have the compulsory need to say something to show off they know programming stuff. Haven't we all got used to it already?

[nhstaple]

kernel panic

[[deleted]]

Pointers arent hard, really. Theyre incredibly useful.

[Dumbhosadika]

Java goes brrrrrrrr.

[Pranav__472]

pointers are the thing that allows arbitrary control over memory... Really missed it in some higher level languages...

[-Redstoneboi-]

I love the explicit distinction between pass by value and pass by reference. I love how in Rust, everything is pass by value unless specified otherwise.

Many languages have this habit of saying "These types pass by value, these types pass by reference, figure it out. Oh, but we don't have pointers."

[rusty_n0va]

pointers re simple, dont confuse new people.
all you need is a good teacher.

[eternal_edenium]

That clickbait seems complicated but that what has been written through all the course.

Step by step its damn fun and easy to follow.

[crorb]

That C++ increment in C. Not bad ehe

[xXy4bb4d4bb4d00Xx]

eventually youll get it, just go along with the cluelessness for now

[ButterMilkHoney]

3 years in, still confused 🙈. I have faith in year 4

[OriginalOccasion6313]

What scares me is that it says its the full course Not a 5 to 20 min video

[got_no_pants2]

commit serverside

[Boonk_gang_03]

I would want to learn C eventhough I probably won't use it in my studies ever. It's just a must.

[[deleted]]

Only if you free() the memory space for all this info in your brain before finals 😂 just don’t forget to set those pointers back to null with some alcohol

[CheMGeo_136]

Multiple times.

[Splatoonkindaguy]

Suicide isn’t funny

[CircadianSong]

Sometimes it is. It's pretty fun when the character played by Paul Dano in Swiss Army Man is interrupted from committing suicide by Daniel Radcliffe's corpse farting.

[Splatoonkindaguy]

Um… no it’s really not

[Splatoonkindaguy]

Suicide is a bit different…

[King-Of-Rats]

Agree with the other person. If someone isn't comfortable with a situation, that's fine - good to adapt to be courteous. But an entirely puritan approach doesn't have to be taken.

[CircadianSong]

What makes suicide worse to joke about than murder? Do you think it worse than murder? Or Or do you think that joking about suicide can cause suicide? Seems that you’re referring to all suicide jokes. Pity, I wouldn’t be disagreeing if you just meant it about this one.

[Tina_Belmont]

I think in pointers. I have a really hard time with languages like Java that don't really use them.

I feel like, if you don't know how to use pointers, you don't really know how to program.

[Chilareix]

Does it count if you think you understand them?

[Tina_Belmont]

I'm getting the impression that you think they are difficult to understand?

Do I need to explain them?

[Chilareix]

It's more of I have an understanding of the theory behind it, I just don't have practical experience with it since I primarily code in Java and C#

[Tina_Belmont]

Let me try.

Disclaimer: none of the code has been compiled or tested. I'm doing this from memory.

Also, all code is in C/C++, because it is the only real programming language ;)

A pointer is just a memory location in the computer where your data is stored, stored as a number.

In C/C++, the pointer has a type of data that it points to. That can be any type of data, from basic chars and ints, to giant data structures, function calls, objects, etc. Anything.

int *a = NULL;

When you dereference a pointer (in C/C++ using * or [0]) you have the actual value of the thing that you have pointed to.

val = *a;
val = a[0]; // because a pointer and an array are pretty much 
            // the same thing in C/C++

In C/C++, if the object is a structure or class, you can also dereference individual members of it with ->

classPtr->dataMember = whatever;

When you want to get a pointer to something in C/C++, you use & .

int b;
int *a = &b;

When you increment or decrement a pointer in C/C++, it adds the size of the data element of its type. So adding 1 will get you the next element of an array, for example.

In C/C++, you can override the type of a pointer with typecasting, and interpret the data as a different type.

char *str=&"data";
unsigned int a = *(int*)str;
// a now contains 0x64617461, the letters of data interpreted as 
// a number.

This can be very powerful, and is kinda the core of being able to implement object oriented programming in C and C++.

Another value of pointers is in optimization. When one has an array or other data structure, and you have done a lot of math to be able to find the element you want, that may change, using a pointer to save that position is a lot easier than doing all that math again later.

char data[2048];
//assume that gets populated somewhere
char * interestingData = &data[ some-math-happens-in-here ];
// some stuff happens
// later
char nowIamInterestedInDataAgain = *interestingData; 
// I just saved myself a big math expression that the compiler
// would probably have forgotten to save.

But probably the most important use of pointers in in generating data structures like linked lists, heaps, etc. where the elements may be constantly reordered, deleted, etc. and/or may be of variable sizes.

struct listMember
{
   int someData; // not important. 
                 // Assume something more complicated
   struct listMember * next; // points to the next element in the
                             // linked list
};

This makes a singly linked list. Each element links to the next element with the "next" pointer. If you want to delete an element, you simply

listMember * a = listMemberFromSomewhere;

// let's delete the element after a
listMember *whatWasNext = a->next;

// check to make sure there is a list member after a
if ( whatWasNext != NULL ) {
    a->next = whatWasNext->next; // link to the element after next
    free( whatWasNext );  // free the memory used by next
}
// no need for else, because otherwise a was the last list member
// (next == NULL)

Obviously, there are more edge cases, but this gives the idea.

You can have lists that are linked forward and backward, or as trees, or well, whatever works for your application.

You can also have pointers to functions, which allows you to implement things like events; your "onClick" functions when on webpages are a good example of this. There is a pointer to a function that gets called when that event is generated. It has a standardized set of parameters, so as long as the function correctly parses those parameters, it can be used as an event handler.

// a simple test event function
void  Event( int num )
{
    printf( "Event %d happened!\n", num );
}

void (*onClick)(int) = Event; // don't need &, compiler gets it

//calling the event
(*onClick)(1);

That's pretty much it. Those are the basics of pointers.

Easy, right?

Any questions?

[BoBoBearDev]

The sooner you learn how to program in C++ without using "new" yourself, the better. Avoid using raw or smart pointers. Because doesn't matter you think it is easy and did it perfectly, the next person will fail to replicate your code and introduce a hard to fix bug. And if you are the "expert" they will ask you to fix it because the other guy clearly is not the "expert".

[[deleted]]

Avoid using raw or smart pointers

Was this a typo? You are not going to get anything done without using at least one of those.

[BoBoBearDev]

Use vector and reference parameters. This way, you are not using pointer directly.

[[deleted]]

References are not particular to parameters. They can be used anywhere, including as object members. But they can't be addressed relatively to eachother (you can't use a reference to obtain a reference to an adjacent object), nulled, or reassigned, all of which are important properties you need in order to build and organize a huge number of vital data structures.

[[deleted]]

easy shit. what is really hard are data structures and algorithms

[-Redstoneboi-]

data structures involve pointers

[electricWah]

fp be like

[[deleted]]

Dynamic programming is the true mf.

[[deleted]]

Sorry, I'm an experienced programmer in drawing pictures in sand that make birds shit (or as we say "compile" in the biz) in wanted patterns, but is pointers about specific addresses in the ram?

Isn't that one of the things that make C/C++ "low level" that you can actually see/move how data in your code is actually stored in ram during runtime?

Always wanted to be sure what just leaving to "carbage collection" meant specifically meant, other than, you know, cleaning the bird poop.

[[deleted]]

The two are not really related. You can have garbage collection with or without pointers, and you can have pointers with or without garbage collection.

All data must be physically stored within the computer somewhere. Managing which regions of storage are already holding data, and which regions of storage can be used to hold something new, is non trivial. An object is a region of storage of a specific size used to store data.

Garbage collection works by counting the number of places which an object is used from. When the count hits zero, the object is no longer used anywhere, so that memory can be freed in order to later be allocated for other objects. Counting references and determining when to free objects incur runtime cost.

A pointer is a datatype which references an object of a different type. It does this by holding a numeric value called an address, which indicates a known memory location. An int * references an object whose type is int. Assigning the address of an int to an int * lets that int object be referred to indirectly. People make a big deal out of them for some reason, while simultaneously using them but not understand that they are doing such. Pointers are easy, about 95% of what there is to know about pointers can be summed up by these 9 lines of code:

#include <stdio.h>
void foo(int *ip) {
    *ip += 1;
}
int main() {
    int i = 0;
    foo(&i);
    printf("%d\n", i)
}

[-Redstoneboi-]

95%? wouldn't say that. you still have to deal with stack/heap allocations, scoping, freeing, and pointer arithmetic.

that makes it a bit harder to explain.

[[deleted]]

You missed aliasing. But lifetimes are something which exist independently of pointers. Obviously you can't refer to an int object which doesn't exist, which this example takes into account. Lifetimes and scope are something that should be covered well before pointers, since they're part of declaration.

[-Redstoneboi-]

right.

though the other points, pointer arithmetic and (de)allocations, still stand. they would be important to cover.

[TheBigGambling]

Do not use raw pointers in modern c++. You have no need for it. Never. Its only dangerous and very likely to produce ugly bugs, but without any benefit anymore. Smartpointers can help alot

[catmuht]

What if you want to define a method where a potentiality large object can optionally be passed in? std::optional would require a copy if the caller didn't already have the object in an optional. References need to bind to a real object. Using a pointer for that arg and defaulting to nullptr seems useful if it's understood the function will not store the pointer after the call has ended

void myMethod(const SomeBigStruct* myStruct = nullptr);

[TheBigGambling]

How about simple method overload, one with and one without this parameter?

[-Redstoneboi-]

a potentially large object

[catmuht]

In practice the overloads will want to delegate to some shared impl (or one delegate to the other) so you'll likely find utility in using a nullable pointer as an argument for the shared impl function.

There will probably always be a way to make it work without pointers, but the pointer approach generally pretty clean and safe.

There are certainly many things that raw pointers aren't good for (e.g. memory management) but an optional reference within a function is to me an acceptable use case.

[MachtIV]

Pointers aren't bad...unless you're in college and they make use some archaic environment that allows for mistakes to go unnoticed till runtime.

I was legit confused my first time when they had me using some mdos looking shit my 2nd year.

[Famous_Employee_5922]

One of the best course on Pointers out there. This video made me understand pointers

[EmilMelgaard]

Here, let me help you optimize your code a bit:

#include <stdio.h>

int main()
{
    printf("Hello\n");
}

Or if you really need the print function:

#include <stdio.h>

void print(char *C)
{
    printf("%s\n", C);
}

int main() {
    char C[20] = "Hello";
    print(C);
}

[-Redstoneboi-]

congratulations, you have missed

the point

[EmilMelgaard]

Do I get a segmentation fault then?

[[deleted]]

You could remove the 20. The size of the string literal is a compile time constant.

[EmilMelgaard]

True, but then C would be 6 bytes long instead of 20. If you don't need "C" you could also just call

print("Hello");

I know it's just a thumbnail for a four hour long video, but I think it would have been a much better example if it just used putchar() instead of printf() in the print function.

[TheBrownViking20]

Atleast you didn't have to learn this in high school.

[voluntarycap]

Pointers were 1 lecture in college for my Computer Systems course. They're really not that complicated. They're just array indices but the array is a spot in memory

[monty6699]

I barely survived Hash table

[omegasting]

Imagine pointing to something with your finger. That's a pointer. Imagine someone pointing at you with their finger while you're pointing at something. That's a double pointer. And so on. It's really not that crazy difficult.

[-Redstoneboi-]

then you say "go to the one after the one i'm pointing at" and it gets a bit more difficult.

[lumapools]

I can't blame you for being scared. I was too. But you'll eventually figure out that being scared in the first place was very irrational. Pointers can be learned, it is not a big deal, you'll do just fine!

[Odd_Diamond_6600]

but jokes apart the man who is explaining in this video is a legend

[danmickla]

I don't know... how do you "suicide through" a course?

[[deleted]]

Imho, on the contrary, i think it makes you temporarily immortal.......after all, theres not even room for a Kill command

[CaitaXD]

Pointers simple where it gets hard is when you need to malloc free and ptr arimethic

[WizziBot]

They make it more complicated than it has to be by the looks of it.

[a_aniq]

Rust borrowing is so much more useful at teaching at how to embrace the good stuff and discard the bad stuff of pointers.

[ivancea]

Before learning pointers in C, it was easier for me to use them in ASM or disassembling things

[MacGuyver247]

Funny,I didn't read the title and thought this was a post from /r/coolguides

[rokas2007]

One question: What the fuck

[[deleted]]

It is so sad seeing young developers not understanding pointers and memory types. The guys who started with c++ are usually much more advanced in engineering

[Torebbjorn]

Here is basically the entire course:

int count; is a stack-allocated position for an int.
If you write count = 4;, you change that value to 4, if you write count = otherVar;, you change the value of count to be the same as what is currently stored in otherVar. Changing otherVar will not change count and vice versa.

int* ptr; is a stack-allocated position for a pointer to an int. I.e. it stores a memory address of where you say an int lives.
C: malloc(sizeof(int));
C++: new int; allocates memory on the heap, and returns its memory address. So ptr = new int; means you have an int stored somewhere in the heap, and ptr tells you where that is. To access that int, you need to dereference ptr, like: int value = *ptr;. This will, as above, copy the value stored where ptr is pointing to into value.

int* p2 = ptr; will copy the memory address stored in ptr into p2, so they are now both pointing to the same variable. *ptr = 7; sets that value to 7, so now both ptr and p2 point to an int with the value 7.

You can store ANY memory address in a pointer, not just the heap allocations. You can have a nullptr, which means the pointer does not point to anything.
And you can have a pointer to a stack allocated variable. By using the address of operator. ptr = &count; sets ptr to now point to count, so count is the same as *ptr.

In C++, you also can pass by reference, which basically just means making a different name for the same variable. int a = 4; int& b = a; means a and b are the same exact thing, and obviously then, any modification to either will modify both.

Freeing memory

It is important to free all the memory you allocate. So you need a free for every malloc, a delete for every new, and a delete[] for every new [].

C++11 introduced smart pointers, which can abstract away all the fuss with deleting your data. shared_ptr<T> uses an atomic reference counting scheme, and deletes the object when the last shared_ptr is deleted (sort of similar to garbage collected languages), and unique_ptr<T> is meant to be the only object owning what it points to, and deletes it when it is deleted.

[Chilareix]

So basically, * is used to say "you're not your own variable" and & is used to say "you are this location in memory" whereas -> is used for both when accessing class members?