Pointers in C

Go and Rust did pointers better.

There is no "reference" in C. Pointers are your references.

fpbp

The class was technically in c++, not c

/thread

Pointers are simple to grasp, but C's syntax for them is pretty fugly. Go is an example of how dealing with them could be easy and convenient.

Learn brainfuck it'll help

Read the bible.

Attached: 20190414_015159.jpg (3264x2448, 1.06M)

pointer is a variable that store other variable in the virtual memory

Attached: poc.jpg (403x500, 40K)

Pointers aren't that hard unless you have a retard professor who makes you stand up in class and point to people. When i saw a decent visual tutorial online i got it instantly.

A pointer that points to another pointer is whats hard to grasp
We know pajeet

It's just a variable that stores a memory address, I don't get why people have trouble.

But a reference is pretty much a const pointer with a little syntax sugar and no possibility of being null, e.g. the two below are pretty much the same things, except that you need an asterisk when using the pointer.
int& a;
int* const b; //do not confuse with const int* b;

How is that hard to grasp when you already know what a pointer is?

t. script kiddie

based

This. If OP can't cope with this book xe should change course. Excellent book. By the way, always cast your mallocs :^)

Bad teachers can do that, too.
The worst is when a teacher is inexact and uses pointer and address interchangeably.

>But a reference is pretty much a const pointer with a little syntax sugar
References are resolved at compile time and do not take up space. This is the reason why you cannot have an array of references, but you can have an array of const pointers.

Nice Makarov.

Why is C++ such a terrible language. All these overloaded operators, "smart" design choices which make like an actual clusterfuck out of simplicity... I hate it.

You can have either a simple language, or simple code. Or in case of C++, neither. But I still prefer C++ to C. And the main problem with C++ is layers of legacy garbage piling up (starting with C), which is the main reason for creating something new.
But if you restrict yourself to using only the "current" stuff, it's actually pretty decent. But in any real project, you'll have tons of legacy code and there's nothing you can do about it.

.h & .cpp file make cpozpoz an absolute nightmare. I just try shit until it compiles when it comes to object dependencies because FUCK learning that shit, theres no clean guide for any of this

Attached: sniffety sniff snif.png (162x194, 29K)

forward-declare in the .h, includes as much as they can in the .cpp

agreed, although it takes some getting used to at first

This. It amazes me how many people don't understand such a simple concept.

int a;
int b;
int *p;

p = a; //assign the value of a to p
*p = b; //assign the memory address of b to *p

return *p // returns the value at the memory address of b
return p // returns the value (a) that was assigned to p

my most complex c program is fizzbuzz; did I get this right?

let me test holup

returning p gives you the address in memory.

>brainlets using C
Come home white man, assembly is waiting for you.

ah okay

sir... why lie

Attached: memed me.png (1112x1656, 87K)

Type syntax is retarded. Pointer arithmetic is retarded

god I hate this python generation
pointers are not hard. A week after you learn of it you might get confused, but after a while it makes more sense than whichever bullshit pointerless programming languages do.
And no, string is not a type. Fuck off

string is just an array of chars, and an array is a series of pointers

>being a brainlet

>language that doesn't abstract addressing with proper types and value categories

who's the real brainlet?

what if a string is just simply a string?

what if an array is merely an array holding type T and of a fixed size of Y?

why do you have to specify data type of what a pointer points to in C?

int a;
void *p = &a;
You don't

i don't understand. its literally just shit pointing to a memory location, and not a value. then you can dereference (as in, instead of it referring to a location, it can refer to a value) the pointer, and get the value. its very useful, and a super simple concept. things are stored in memory, in a stack, with a range of address that grows bottom up. it points to one of those, but not what's in it.

golangs pointers are for type safety needing faggots. real mean deal with void pointers

Also arrays vs pointers in C adds needless confusion.

>wahh do it for me language daddy.
you are the brainlet, baby boy.

I don't find them confusing. Pointers are pointers and arrays are arrays. What's confusing about that?

Go and Rust pointers are the equivalent of eating a salad instead of a burger

Could you explain in a few sentences what an array is and how it relates to pointers? I've always been confused by arrays and they seem like kinda pointers not not really. E.g. I've read that when you write
int a[5]
a is a pointer to the first element of the array. So how does one refer to the array itself?

They are both datatypes. A pointer is a variable that stores an address. An array is a contiguous set of addresses used to store data. A string uses a pointer to the first element of an array so your program can read the value of each element in the array and read the string. You can have an array of pointers, you can have an array of structs. You can have an array of ints or chars.

you say they are both datatypes but that seems to obscure a real difference. If I write
int a
then a is an int. If I write
int a[5]
the a is not an array, as far as I understand things. a is a pointer to the first element of an array.

When you write int a[5]; then you have declared an array of 5 int elements called a. That array can store a 4 letter string with a final null byte. There's going to be a pointer that points to the first byte. The whole array carries the name a. Not the pointer. The pointer is under the hood.

Okay. Granted. Your array is int. So technically it can't be a string but the idea is what I'm trying to convey.

People are still learning c? Lol

everyone gets niggly about pointers because it seems like voodoo. the only problem i had with pointers at first was understanding that you can have pointers to pointers and when that's useful.

>The whole array carries the name a.
Now I see this is correct
>The pointer is under the hood.
This is right but then C will immediately convert a to a pointer to the first element if you treat it like a pointer, e.g. *(a + 1) is valid and C will treat a like a pointer to the first element of the array when you write this.

I'm a newb. What's a situation when a pointer to a pointer is useful? This thread has already helped a lot.

In c, a is an array until you pass it somewhere else. Aka array decay.

Because data alignment and addressing. Otherwise you would have to do your own arithmetic to access types larger than a byte.

I don't think doing p + x*sizeof(datatype) isn't bad.

you create a pointer to a struct or something in a procedure, and you want to initialize that object somewhere else (say, an init function), so you pass the pointer into the function. the function will have to reference it as a pointer to that pointer. you can initialize or allocate your thing in the function there. it's cleaner to do it this way sometimes in my opinion, but i'm not sure if that's the best way to do this.

I use them in my utility functions to free allocated structures. This way my pointers will be set to NULL and makes everything easier overall.

Passing a pointer to a function that modifies the pointer address without losing reference to it.
also a array of dynamically allocates strings is going to be **char, e.g. argv in main.

Understanding it is easy
Trying to use it is hard
I always fuck up passing arrays

Yeah, but you do p++ somewhere and you're fucked. If the compiler is aware of the type of p, a type of int p++ still maintains reference to individual aligned ints. It's basically just sugar to allow you to increment pointers, etc.

>the average rustfag

I have never used rust

You don't pass arrays, so you have also never used C. Arrays decay into pointers, even if the function prototype takes an array. Fucking this up is not knowing C.

Same can be said for c++ as well since it has a real array type.

You understanding is not entirely correct.

p is effectively an address.
*p means "whatever is at that address"

*p = b; // Assigns the value of b to the value p points to

Because a pointer is the address of an OBJECT (not a BYTE), and not every object is 1 byte in size.
So you can increment a pointer to say next OBJECT, not next BYTE.

Seriously this is like complaining about punctuation. If pointets are an issue for you then you are not cut out for computrr science. Try a code monkey course while on HRT otherwise off to Mcdonalds to you.

I have used c. I never claimed to be not shit at it.

>brainlets

go back to coding online shops in wordpress pajeet

dunning krugger right here

Why are C programmers on Jow Forums the most insufferable people?

>programming in C is hard, you're still quite close to the metal, making genuine abstraction is hard, and overall there are a lot of ways to screw up and go wro-
>WHY DOES ANYONE NEED PROPER TYPE SYSTEMS AND WELL-DEFINED BEHAVIOUR?
>C IS EASY, JUST DON'T MAKE MISTAKES RETARD

I'm just getting into polymorphic inheritance
D:

oops, I forgot it only works with pointers, some tips:
first, why include B in the header of A, you don't even use it there, remove it.
second, to forward declare, cut
>#include "A.h"
from B.h, and paste into B.cpp. then before your class definition "class B {" put:
>class A;
also, the include should be in the .cpp, your header doesnt use it and "using namespace" is bad practice.
complete example in pic.

Attached: dependency-loop.png (2000x1500, 294K)

A memory address and a pointer aren't the same. "a" without a subscript gives you the memory address of the first byte of the first element of the array but "a" isn't a variable like a pointer. "&a" will give you the same address as just "a" because "a" is already a memory address.

An array in C is a pointer to the first element. There are no "array" data types in C. Using array[x] for element access is just short for *(array+x). Nothing more than syntax sugar

Passing 3d struct arrays to a function in C is the ultimate test of courage

Attached: 1513647646562.jpg (1024x872, 186K)

Just read the replies, and most of them fail to mention the most important aspect of C. There is *no such thing* as an "array" in C. Also no, an array isn't "a bunch of pointers to variables". When you declare an "array" in C, the compiler/linker is statically reserving x bytes of memory. Your array variable is just a pointer to the beginning of the reserved memory area (not the first element). Your array variable is just a pointer. All pointers in C (except void), support the ptr[x] syntax, which allows you to "index" the pointer by applying an offset to the location it points to. The offset is calculated by the size of the type, multiplied by the index and added to the pointer's address.

/thread

>pointers in C
What's the issue for most people?

I didn't learn pointers yet, but after looking at some wiki entries it doesn't look to frightening.

>I didn't learn pointers yet, but after looking at some wiki entries it doesn't look to frightening.
lol
There's no issue if you understand computer architecture, however most people don't.

>bitching about the 'complexity' of c pointers
>not investing time in learning modern languages and frameworks
good luck OP getting fucked by the masses of pajeets with your basic knowledge

Only about 3 people in this thread understand why

Honestly this. You look at memory and what is actually plonked in the addresses and pointers make perfect sense. Just without this it's confusing and meaningless.

Its not that bad. Practice it a lot and you'll understand it eventually.

>>There's no issue if you understand computer architecture
>computers have singular dimension memory

lmaoing at you deluded C cucks.

I admit, it requires some mental gymnastics to understand that.

For instance:
int a; // declares and defines variable in stack, not recommended
a; // evaluates uninitialized value
a = 5; // assign value of 5
// int a = 5; this is initialization
// int a{5}; c++11 initialization list
a; // evaluates 5
&a; // evaluates an address of a, & is an unary operator here

int * ptr; // declares and defines variable in stack, the "*" declaration tells it will be a pointer, ie. uses compile native addresation, the int tells how to interpret it and of what size it is
void * vptr; // ditto; it can store address, but compiler doesn't know how to handle content

ptr = &a; // ok
vptr = &a; // ok

ptr; // evaluate the value, i.e gets address of a
vptr; // evaluate the value, i.e gets address of a

&ptr
&vptr; // evaluate variable address, NOTE: &ptr != &a

*ptr; // derefence, it will evaluate value of a
// *vptr; compiler doesn't know what to do here

Why does this chapter have the mark of the dark lord?

>Your array variable is just a pointer
memory address.
technically arrays are closer to structs. pointer is a memory address in which another memory address is recorded. struct variable holds the address of the beginning of the memory where struct is recorded.

>All pointers in C
all variables

Attached: index.png (211x239, 5K)

>Memory management
I'm not sure if it's computer memory or your own memory

>C