One benefit of pointers is when you use them in function arguments, you don't need to copy large chunks of memory around, and you can also change the state by dereferencing the pointer.
For example, you may have a huge struct MyStruct, and you have a function a().
void a (struct MyStruct* b) {
// You didn't copy the whole `b` around, just passed a pointer.
}
One benefit of pointers is when you use them in function arguments, you don't need to copy large chunks of memory around, and you can also change the state by dereferencing the pointer.
For example, you may have a huge struct MyStruct, and you have a function a().
void a (struct MyStruct* b) {
// You didn't copy the whole `b` around, just passed a pointer.
}
Coming from Java, you'll have a slightly different perspective than what is presented in K&R (K&R doesn't assume that the reader knows any other modern programming language).
A pointer in C is like a slightly more capable version of a reference in Java. You can see this similarity through the Java exception named NullPointerException. One important aspect of pointers in C is that you can change what they point to by increment and decrement.
In C, you can store a bunch of things in memory in an array, and you know that they are sitting side by side each other in memory. If you have a pointer to one of them, you can make that pointer point to the "next" one by incrementing it. For example:
int a[5];
int *p = a; // make p point to a[0]
for (int i = 0; i < 5; i++) {
printf("element %d is %d\n", i, *p);
p++; // make `p` point to the next element
}
The above code uses the pointer p to point to each successive element in the array a in sequence, and prints them out.
(Note: The above code is an expository example only, and you wouldn't usually write a simple loop that way. It would be easier to access the elements of the array as a[i], and not use a pointer there.)
What are use cases and advantages of pointers? - Software Engineering Stack Exchange
What is the purpose of pointers in C/C++? What benefits do they provide?
benefits of pointers in c?
what's the benefits of having a variable or value that holds 0 adress memory
0 isn't a valid memory address. If you mean "Why do you allow a pointer to hold 0 if it can then incorrectly be used to address memory"...C needed a way to indicate "invalid or unassigned pointer", and 0 was chosen because it is invalid.
Some more modern languages do distinguish between "pointers that are allowed to be invalid" and "pointers that can't be invalid".
More on reddit.comWhat's the point of pointers?
-
Since everything in C is pass by value, if you want to write a function that modifies a variable, your choices are either pass a pointer to the variable or use a global variable. Obviously the latter is to be avoided as it quickly gets messy and unmaintainable.
-
Similarly, you do not want to be copying around large data structures (e.g. structs) to pass them to functions, so you need to pass pointers for efficiency.
-
Since an array degrades to a pointer, pointers are necessary if you ever want to pass arrays to functions. And 'ragged' arrays (i.e. arrays of pointers) are the only way to pass to a function an array of 2 or more dimensions whose dimensions are not known at compile time.
-
Pointers are required for any sort of dynamic memory allocation. Any data structure whose size is not known at compile time will need to be allocated with malloc/calloc/realloc/alloca/etc, which means pointers.
-
Pointers are required to implement advanced data structures like linked lists, trees, heaps, graphs, etc.
-
Pointers to opaque struct tags provide one of the only means of data hiding/encapsulation that C provides. This means you can write a library that has data structures whose members are not exposed or visible to users, yet can still be passed to and returned from functions. For this reason it's extremely common for library APIs to deal with pointers as basic data types, such as the streams (FILE *). Or look at the pthreads API -- they all take pointers to
pthread_attr_torpthread_mutex_tor whatnot.
Videos
Pointers are necessary for dynamic memory location, many data structures, and efficient handling of large amounts of data. Without pointers, you'd have to allocate all the program data globally or in functions or the equivalent, and you'd have no recourse if the amount of data grew beyond what you had originally allowed for. I hesitate to use absolutes here, but as far as I know all modern computer languages have pointers in some form or other.
In most languages that use pointers, there are certain sorts of references that are pointers, and perhaps certain sorts of references that aren't, and there is no further notational difference. A Lisp cons cell is a pair of pointers, although a fixnum is not a pointer. In Java, the variable used for the instance of a class is a pointer, but an int isn't. The language syntax doesn't reflect that.
C is unusual in that pointers are optional, explicit, and allow explicit pointer arithmetic. It is perfectly possible to write struct foo bar; struct foo * baz;, and once you've allocated memory for baz you can use both bar and baz to represent struct foos. Since pointers are optional, it is useful to have notational differences. (It's essential in C++ for smart pointers, as given boost::shared_ptr<foo> bar;, bar.reset() has one meaning and bar->reset() is likely to have a much different one.)
(Actually, explicit pointers were often used in other languages when C was originally being developed, such as ^ in Pascal. C is an older language than most in common use today, and it shows.)
One of C's design goals was to write Unix in, and therefore it needed to handle memory locations in a detailed manner. (C is actually one of a family of system implementation languages common when it was being designed, another example being Cybol for Control Data computers. C is the one that became a big hit.) Therefore, it is possible to manipulate C pointers directly, assigning memory addresses and calculating new ones. This also led to some design decisions in C. C arrays are based heavily on pointer arithmetic, and indeed an array decays into a pointer in very many situations. Passing variables to C functions by reference is done by pointer. There was no strong need for arrays and passing variables by reference in the form that other contemporary languages had, so C didn't get those.
So, the answer is that, in most languages nowadays, you use pointers constantly without being reminded of the fact. In C, and to a lesser extent C++, you use pointers either to do low-level things, or as accomplish higher-level things that there's no special notation for.
Complex data structures. You can't build something like a linked list or a binary tree without pointers.
There are no "pros" and "cons" of pointers. They are just a tool, like a hammer.