I am a little confused on both pointers and reference.
From my understanding pointers are addresses in memory.
In general, they are both addresses in memory. Usually one speaks of pointers if arithmetic can be done on them and of references if not, but there are some language-specific variations.
If I pass a variable using pointers and reference to a function, any
manipulations of the variable in the function will change the original
variable.
Yes.
But there are three reasons for passing something by reference:
- To avoid copying large amount of data to the stack.
- To modify the original variable.
- To support polymorphism, as the generated code does not know in advance how large the object will be and how to properly copy it.
Code using the second option is always more difficult to read than code using return values and if it is not used consistently, it is a sure way to create real mess. To distinguish this case from the other two C++ has the const modifier. Unfortunately Java and C# don't (and their authors don't seem to understand why it is useful; might have something to do with the fact that many people sell const in C/C++ as optimization tool which it certainly isn't).
I read online that passing by reference is not encouraged because it can get messy code easily.
High level languages hold everything by reference, because of the reason 3 above. They may pass the reference by value (just like passing pointer in C; the function can't change where the pointer points, but it can change content of the pointed object) or by reference (that is pointer-to-pointer; the function can make the variable point to different object), but it is always a reference to the actual object.
Java does that except for primitive numeric types and C# does it for everything that is class.
But passing by reference for the reason 2 above is indeed discouraged. One simply does not normally expect function to modify it's arguments, so better not do it.
I also read here (https://stackoverflow.com/questions/7058339/c-when-to-use-references-vs-pointers), that we should avoid pointers if we can.
That is C++-specific. References can't be set to nullptr (0 in older C++) so you don't have to check and references can't be deleted, so you don't have to think whether you should.
My question is when should pointers and reference be used?
Wherever they have to be.
I know pointers are used in Xcode for strong references and reference
counting. Since, higher level languages like c# have garbage
collector, does that mean we shouldn't ever use pointers and reference
in them?
Managed languages (C#, Java, ...) don't have pointers at all. Pointers allow access to raw memory and that would interfere with the managed runtime. So they don't have them (C# does, in the special, "unsave", extension, to allow interfacing with plain old C libraries).
But references can't be not used in them. Everything is a reference. Because allocated memory can only be handled by pointer/reference. And because of polymorphism. So all variables of object types are references in Java and C# and all variables are references in anything dynamically typed like smalltalk, perl, python, ruby, javascript etc.
In the C++ view of the world, a literal does not occupy any memory. A literal just exists.
This view makes that there is no address for a pointer to refer to when it would point to a literal and for that reason, pointers to literals are forbidden.
Const references are actually the exception here in that they allow apparent indirect access to a literal. What happens underneath is that the compiler creates a temporary object for the reference to refer to and that temporary object is initialized with the value of the reference.
This creating of a temporary that the reference gets bound to is only allowed for const references (and gets used in other scenarios as well, not only for literals), because that is the only case where a reference/pointer to a temporary won't have undesired side-effects.
Best Answer
There are 28192 possible different 1K blocks. Storing them all would take 28202 bits of storage. Since the universe contains only about 1080 (or ~2266) particles, it's a safe bet that it isn't possible to store them all, and you don't have to wonder about whether it would save time or not.
But there is, in fact a more interesting way of answering this. You are suggesting creating an index into a huge pool of constants. But how would you know which index to dereference? Imagine for the sake of an argument that you want to store only 1-character blocks:
a,b,c... Presumably your indices would be 0, 1, 2 etc., since that's the most efficient layout of storing those blocks.Do you notice something about the arrangement? Your index is, in fact, a coded representation of the stored data! In other words, you don't have to dereference at all, you just have to transform the index into the data you want.
When you store all possible values of something in a table, this always happens: your index becomes merely an encoded version of the data itself, so storing the data becomes unnecessary in the first place. This why in the real world, indices are only useful for sparse data (e.g. all web pages you've visited, not all web pages that could exist, or even all that do exist).