- \r\n
- What is a pointer?<\/a><\/li>\r\n
- A simple example<\/a><\/li>\r\n
- Going deeper<\/a><\/li>\r\n
- Reading an area of memory using pointers<\/a><\/li>\r\n
- Arrays<\/a><\/li>\r\n<\/ul>\r\n<\/li>\r\n
- References<\/a><\/li>\r\n
- Parameter passing<\/a>\r\n
- \r\n
- Call-by-Value<\/a><\/li>\r\n
- Call-by-Reference<\/a>\r\n
- \r\n
- Too many return values needed?<\/a><\/li>\r\n<\/ul>\r\n<\/li>\r\n
- “Call-by-Pointer”<\/a>\r\n
- \r\n
- Passing objects<\/a><\/li>\r\n<\/ul>\r\n<\/li>\r\n
- Pass arrays<\/a><\/li>\r\n<\/ul>\r\n<\/li>\r\n<\/ul>\r\n\n
Pointers<\/h2>\n\n
What is a pointer?<\/h3>\n\n
Before we get to the question of what a pointer is, let’s take a step back: What is a variable? A variable is a reserved place for data that you can change during the execution of the program. A variable has a name, a data type, a specific address and a specific value. The data type determines the memory space to be reserved.<\/p>\r\n\n
A pointer is also a variable. However, it is special in that its value is the (initial) memory address of another variable or object. So, the pointer does what its name suggests: It points to something else. <\/p>\r\n
When defining the pointer, the data type of the “target” must be specified. Without this additional information, it would not be known at which address the target ends in memory and how to interpret it.<\/p>\r\n\n
A simple example<\/h3>\n\n
Since these explanations are very theoretical, let’s have a look at a practical example.<\/p>\r\n\n
void setup(){\r\n Serial.begin(9600);\r\n \r\n int iVal = 42;\r\n Serial.print(\"iVal = \");\r\n Serial.println(iVal);\r\n \r\n int *iPointer; \/\/ alternative: int* iPointer;\r\n iPointer = &iVal;\r\n Serial.print(\"*iPointer = \");\r\n Serial.println(*iPointer);\r\n \r\n iVal += 4200;\r\n Serial.print(\"iVal = \");\r\n Serial.println(iVal);\r\n Serial.print(\"*iPointer = \");\r\n Serial.println(*iPointer);\r\n}\r\n\r\nvoid loop(){}<\/pre>\r\n\nAnd this is the output:<\/p>\r\n
\n![\"Pointer](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/10\/Pointer.png\")
<\/a>Output pointer_basic.ino<\/figcaption><\/figure>\n<\/div>\n Explanations to the sketch<\/h4>\n\n
First, the integer variable iVal is declared and assigned the value 42.<\/p>\r\n
With
int *iPointer<\/code> we create the pointer iPointer. The character*<\/code> specifies that this is a pointer.int<\/code> specifies that the target, i.e. the object to which the pointer points, is an integer.<\/p>\r\nHowever, at the time of declaration, we have not yet defined where the target is, i.e. where the pointer points to. We achieve this with
iPointer = &iVal;<\/code>. iPointer then points to the address of iVal. The character&<\/code> is the address operator.<\/p>\r\niPointer is the pointer itself. To get the value pointed to by iPointer, you must prefix the pointer with the indirection operator
*<\/code>. The indirection operator is also called the dereference operator.<\/p>\r\nIf we now change the variable iVal, it is still at the same address. Therefore, the instruction
iVal += 4200;<\/code> has no effect on iPointer, but it does on its target value *iPointer.<\/p>\r\n\nGoing deeper<\/h3>\n\n
I wrote the following sketch to expand on the topic:<\/p>\r\n\n
\r\nvoid setup(){\r\n Serial.begin(9600);\r\n delay(2000); \/\/ needed for some boards\r\n\r\n int iVal = 4242;\r\n int *iPointer;\r\n iPointer = &iVal;\r\n \r\n long iLongVal = 42424242;\r\n long *iLongPointer;\r\n iLongPointer = &iLongVal;\r\n\r\n long long iLongLongVal = 4242424242424242;\r\n long long *iLongLongPointer;\r\n iLongLongPointer = &iLongLongVal;\r\n \r\n Serial.print(\"iVal = \");\r\n Serial.println(iVal);\r\n Serial.print(\"iLongVal = \");\r\n Serial.println(iLongVal);\r\n Serial.println(\"Sorry, can't print iLongLongVal\"); \r\n *iLongPointer += 1;\r\n Serial.print(\"Updated iLongVal = \");\r\n Serial.println(iLongVal);\r\n Serial.println();\r\n\r\n Serial.print(\"iVal address = \");\r\n Serial.println((int)&iVal);\r\n Serial.print(\"iPointer value = \");\r\n Serial.println((unsigned int)iPointer);\r\n Serial.print(\"iPointer address = \");\r\n Serial.println((int)&iPointer);\r\n Serial.print(\"*iPointer = \");\r\n Serial.println(*iPointer);\r\n Serial.println();\r\n \r\n Serial.print(\"Size of iVal = \");\r\n Serial.println(sizeof(iVal));\r\n Serial.print(\"Size of iLongVal = \");\r\n Serial.println(sizeof(iLongVal));\r\n Serial.print(\"Size of iLongLongVal = \");\r\n Serial.println(sizeof(iLongLongVal));\r\n Serial.println(); \r\n \r\n Serial.print(\"Size of iVal address = \");\r\n Serial.println(sizeof(&iVal));\r\n Serial.print(\"Size of iLongVal address = \");\r\n Serial.println(sizeof(&iLongVal)); \r\n Serial.print(\"Size of iLongLongVal address = \");\r\n Serial.println(sizeof(&iLongLongVal)); \r\n Serial.println(); \r\n \r\n Serial.print(\"Size of iPointer = \");\r\n Serial.println(sizeof(iPointer));\r\n Serial.print(\"Size of iLongPointer = \");\r\n Serial.println(sizeof(iLongPointer));\r\n Serial.print(\"Size of iLongLongPointer = \");\r\n Serial.println(sizeof(iLongLongPointer));\r\n}\r\n\r\nvoid loop(){\/* empty *\/}<\/pre>\r\n<\/p>\r\n<\/div>\r\n\n
A hint<\/strong> that has nothing to do with pointers: With so many
Serial.print(\"text\")<\/code> instructions, consider switching toSerial.print(F(\"text\"))<\/code> to save RAM at the expense of flash (more on this here<\/a>). I have consistently refrained from doing so to focus on the essentials. <\/p>\r\n\nBack to the main topic: before we get to the explanations, here is the output I got when using an Arduino Nano:<\/p>\r\n
\n![\"Pointer](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/10\/pointer_2_output.png\")
<\/a>Output basic_pointer_2.ino<\/figcaption><\/figure>\n<\/div>\n Explanations<\/h4>\n\n
In the sketch, three variables of type Integer, Long Integer and Long Long Integer are defined and output. Long Integer cannot be output with
Serial.print()<\/code>, but that is another topic. In addition to the three variables, pointers are defined that point to the variables. <\/p>\r\nIn line 21, *iLongPointer is incremented. As you can see, this changes the value of iLongVal. This is basically unsurprising, since iLongPointer points to iLongVal.<\/p>\r\n
Using iVal as an example, let’s look in detail at what makes the difference between the variable itself and a pointer to it. Then value of iVal is 4242 and iVal located at memory address 2298. 2298 is the starting address. The size of iVal depends on the data type and the microcontroller used. To get the address of iVal, we use the address operator
&<\/code>. To output the address, it must still be explicitly converted to an integer, e.g. like this:(unsigned long)&iVal<\/code>.<\/p>\r\niPointer has its own address, namely 2296. The access to the address works the same way as with iVal. The value of the pointer, i.e. what you read at its own memory address, is the target address (i.e. the address of iVal), namely 2298.<\/p>\r\n
\n![\"Variable](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/10\/pointer_vs_integer.png\")
<\/a>Variable vs. pointer to the variable<\/figcaption><\/figure>\n<\/div>\n In the following lines of the sketch determines the space needed for the different integer types (int, long, long long). On an ATmega328P based Arduino these are 2, 4 and 8 bytes. “Homework for you”: run the sketch on an ESP32, ESP8266 or SAMD board and see the difference.<\/p>\r\n
The addresses of the integer values have a size of 2 bytes on an ATmega328P based board. This corresponds to the space required by the pointers. So it doesn’t matter how big the object the pointer points to is – the memory needed for the pointer is always the same. <\/p>\r\n\n
Reading an area of memory using pointers <\/h3>\n\n
As you have seen, you can output the value of a variable by dereferencing the pointer to the variable with the
*<\/code> operator. But would it be possible to read the content of the memory at any address? The answer is: Yes and No! Reading the memory itself is no problem – but up to which address? And is it a character or an integer or a float? <\/p>\r\nYou simply have to know the type of the data to be read. The reading is done indirectly using a pointer. Here are the instructions as pseudocode:<\/p>\r\n\n
datatype *anyPointer;\r\nanyPointer = (datatype*)address;\r\nValue of anyPointer = *anyPointer;\r\n\/\/ In short \/ kurz:\r\ndatatype anyPointer = *(datatype*)anyPointer;\r\n<\/pre>\r\n\n
In words: 1) Define a pointer and apply the correct variable type, 2) Assign the address to be read to the pointer, 3) Access the value by dereferencing the pointer.<\/p>\r\n
The following sketch plays with this a bit by interpreting the content of a memory area in different ways. <\/p>\r\n\n
\r\nvoid setup(){\r\n Serial.begin(9600);\r\n delay(2000);\r\n \r\n long iLongVal = 42424242;\r\n long *iLongPointer;\r\n iLongPointer = &iLongVal;\r\n \r\n Serial.print(\"iLongVal = \");\r\n Serial.println(iLongVal);\r\n \r\n Serial.print(\"iLongVal address = \");\r\n Serial.println((int)&iLongVal);\r\n\r\n Serial.print(\"*iLongPointer = \");\r\n Serial.print(*iLongPointer);\r\n Serial.print(\" = 0x\");\r\n Serial.println(*iLongPointer, HEX);\r\n Serial.println();\r\n\r\n byte *jVal; \/\/ alternative to byte: unsigned char\r\n byte *kVal;\r\n byte *lVal;\r\n byte *mVal;\r\n int *nVal;\r\n int *oVal;\r\n long *pVal;\r\n char *kChar;\r\n \r\n jVal = (byte*)&iLongVal;\r\n kVal = (byte*)((int)&iLongVal + 1); \r\n lVal = (byte*)((int)&iLongVal + 2); \r\n mVal = (byte*)((int)&iLongVal + 3); \r\n nVal = (int*)((int)&iLongVal);\r\n oVal = (int*)((int)&iLongVal + 2);\r\n pVal = (long*)((int)&iLongVal);\r\n kChar = (char*)((int)&iLongVal + 1); \r\n \r\n Serial.print(\"*jVal @ address of iLongVal = 0x\");\r\n Serial.println(*jVal, HEX);\r\n Serial.print(\"*kVal @ address of iLongVal+1 = 0x\");\r\n Serial.println(*kVal, HEX);\r\n Serial.print(\"*lVal @ address of iLongVal+2 = 0x\");\r\n Serial.println(*lVal, HEX);\r\n Serial.print(\"*mVal @ address of iLongVal+3 = 0x\");\r\n Serial.println(*mVal, HEX); \r\n Serial.print(\"*nVal @ address of iLongVal = 0x\");\r\n Serial.println(*nVal, HEX);\r\n Serial.print(\"*oVal @ address of iLongVal+2 = 0x\");\r\n Serial.println(*oVal, HEX);\r\n Serial.print(\"*pVal @ address of iLongVal = 0x\");\r\n Serial.println(*pVal, HEX);\r\n Serial.print(\"*kChar @ address of iLongVal+1 = \");\r\n Serial.println(*kChar); \r\n}\r\n\r\nvoid loop(){\/* empty *\/}<\/pre>\r\n<\/p>\r\n<\/div>\r\n\n
Explanations<\/h4>\n\n
First, we define the variable iLongVal so that we have something to read. The variable extends over four bytes (on an ATmega328P board). In the next step we read all four bytes individually, then two each as integer and again all four as long integer. Finally, we read a single byte and interpret it as a character. As you will see, the value of this byte is 0x57 and that is a “W” according to the ASCII table.<\/p>\r\n\n
The structure of the content of the memory area under consideration becomes clearest when using hexadecimal numbers. Here is the output:<\/p>\r\n
\n![\"Output](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/10\/pointer_3__output.png\")
<\/a>Output basic_pointer_3.ino<\/figcaption><\/figure>\n<\/div>\n The practical use of this approach is very limited because we should know what we have written where in the memory. Sorry that I share this only now \ud83d\ude09 . However, I thought that this would be quite useful to further deepen your knowledge about pointers.<\/p>\r\n\n
Arrays<\/h3>\n\n
Strictly speaking, in the field of microcontrollers \/ Arduino one means C arrays when talking about arrays. In C++ there is the much more comfortable class vector. That C arrays are used anyway is simply a matter of limited resources. C arrays are faster and require less memory.<\/p>\r\n
When you define a (C) array, the name of the array is also the identifier of the pointer to element 0 of the array. This is easier than it may sound. It just means that instead of
anyArray[0]<\/code> you might as well write*anyArray<\/code>.<\/p>\r\n\nThe following sketch plays a bit with the pointer properties of arrays:<\/p>\r\n\n
\r\nvoid setup() {\r\n Serial.begin(9600);\r\n delay(2000); \/\/ needed for some boards\r\n \r\n int intArray[4] = {4, 42, 424, 4242};\r\n for(int i=0; i<4; i++){\r\n Serial.print(\"intArray[\");\r\n Serial.print(i);\r\n Serial.print(\"] = \");\r\n Serial.println(intArray[i]);\r\n }\r\n Serial.println();\r\n Serial.print(\"*intArray = \");\r\n Serial.println(*intArray);\r\n Serial.print(\"*(intArray + 2) = \");\r\n Serial.println(*(intArray + 2));\r\n int *arrayElement_3;\r\n arrayElement_3 = &intArray[3];\r\n Serial.print(\"*arrayElement_3 = \");\r\n Serial.println(*arrayElement_3);\r\n Serial.println();\r\n\r\n int *sameArray = intArray;\r\n Serial.println(\"sameArray[]:\");\r\n for(int i=0; i<4; i++){\r\n Serial.print(sameArray[i]);\r\n Serial.print(\" \");\r\n }\r\n Serial.println();\r\n Serial.println(\"Listing by pointer incrementation:\");\r\n for(int *p=intArray; p < intArray + 4; p++){\r\n Serial.print(*p);\r\n Serial.print(\" \");\r\n }\r\n \r\n Serial.println(\"\\n\");\r\n Serial.print(\"Size of intArray = \");\r\n Serial.println(sizeof(intArray));\r\n Serial.print(\"Size of sameArray = \");\r\n Serial.println(sizeof(sameArray));\r\n Serial.print(\"Address of intArray = \");\r\n Serial.println((int)&intArray);\r\n Serial.print(\"Address of sameArray = \");\r\n Serial.println((int)&sameArray);\r\n Serial.print(\"Value of intArray = \");\r\n Serial.println((int)intArray);\r\n Serial.print(\"Value of sameArray = \");\r\n Serial.println((int)sameArray);\r\n}\r\n\r\nvoid loop() {}<\/pre>\r\n<\/p>\r\n<\/div>\r\n\n
Here is the output first:<\/p>\r\n\n
![\"Output](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/12\/array__play__ouput.png\")
<\/a>Output of array_play.ino<\/figcaption><\/figure>\n\n Explanations<\/h4>\n\n
With the knowledge, you have about pointers by now, the output of the sketch is probably not a complete surprise. Nevertheless, at least two aspects are noteworthy:<\/p>\r\n
- \r\n
*(intArray + 2)<\/code> returns the value of element 2 of the array, even though it is “4 bytes away” from the start address on the microcontroller I used (because 2 integers = 4 bytes). On an ESP32 it would work the same way, although an integer has a size of 8 bytes there.intArray + 2<\/code> therefore means “second element of intArray” and not “address of intArray + 2 bytes” or similar.\r\n- \r\n
- Incrementing in the for-construction starting at line 29 works accordingly.<\/li>\r\n<\/ul>\r\n<\/li>\r\n
- Using the pointer sameArray you can access the elements of intArray. You will not notice any difference. Nevertheless: sameArray is not<\/em> intArray, even if both point to the same address. E.g. sameArray has also only a size of 2 bytes and not 8 bytes like intArray. We will come back to this when passing arrays to functions.<\/li>\r\n<\/ul>\r\n\n
References<\/h2>\n\n
References are considerably easier to understand than pointers. A reference is simply a different identifier for the same object. An alias, so to speak. The only confusing thing is that the
&<\/code> character is used again when defining references. Withint &x = y<\/code> you create the alias x for the integer variable y. This is not to be confused with the already knownint x = &y<\/code>, which assigns the variable x the value “address of y”. The character&<\/code> is also called reference operator, which is more appropriate than address operator in this context. <\/p>\r\nHere is a simple example:<\/p>\r\n\n
void setup(){\r\n Serial.begin(9600);\r\n \r\n int iVal = 42;\r\n int &iRef = iVal; \/\/alternative: int& iRef = iVal;\r\n \r\n Serial.print(\"iVal = \");\r\n Serial.println(iVal);\r\n Serial.print(\"iRef = \");\r\n Serial.println(iRef);\r\n\r\n iRef++;\r\n Serial.print(\"Updated iVal = \");\r\n Serial.println(iVal);\r\n}\r\n\r\nvoid loop(){\/* empty *\/}<\/pre>\r\n\nAfter we have created an alias for iVal called iRef with
int &iRef = iVal;<\/code>, both identifiers can be used for the same variable. All changes to iRef affect iVal equally and vice versa because iRef is<\/em> iVal.<\/p>\r\n\n![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/10\/reference_output.png\")
<\/a>Output reference_basic.ino<\/figcaption><\/figure>\n<\/div>\n Parameter passing to functions<\/h2>\n\n
Pointers and references play a major role in parameter passing to and from functions or objects. This is where their advantages really become apparent.<\/p>\r\n\n
Call-by-Value<\/h3>\n\n
“Call-by-value” refers to the “normal” parameter passing to functions or objects, i.e. the way of passing that is usually learned first. Here is an example:<\/p>\r\n\n
void setup() {\r\n Serial.begin(9600);\r\n int iVar = 42;\r\n Serial.print(\"iVar in Setup: \"); Serial.println(iVar);\r\n passAsInteger(iVar);\r\n Serial.print(\"iVar in Setup: \"); Serial.println(iVar);\r\n}\r\n\r\nvoid loop() {\/* empty *\/}\r\n\r\nvoid passAsInteger(int var){\r\n var *= 2;\r\n Serial.print(\"Variable in passAsInteger(): \"); Serial.println(var); \r\n}<\/pre>\r\n\nThe variable iVar is passed to the function
passAsInteger()<\/code> and doubled there. The sketch outputs the value before passing, within the function and after return to setup. The output should not come as a surprise:<\/p>\r\n\n![\"Output](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/10\/call_by_value_output.png\")
<\/a>Output call_by_value.ino<\/figcaption><\/figure>\n<\/div>\n When passed to the function, a copy of iVal is created in memory. The copy is deleted after return from the function, and the original iVar remains unchanged.<\/p>\r\n\n
Call-by-Reference<\/h3>\n\n
The situation is different if we pass the parameter by reference. All you have to do is prefix the parameter with the referencing operator
&<\/code> in the receiving function:<\/p>\r\n\nvoid setup() {\r\n Serial.begin(9600);\r\n int iVar = 42;\r\n Serial.print(\"iVar in Setup: \"); Serial.println(iVar);\r\n passAsReference(iVar);\r\n Serial.print(\"iVar in Setup: \"); Serial.println(iVar); \r\n}\r\n\r\nvoid loop() {\/* empty *\/}\r\n\r\nvoid passAsReference(int &var){\r\n var *= 2;\r\n Serial.print(\"Variable in passAsReference(): \"); Serial.println(var); \r\n}<\/pre>\r\n\nThe output is:<\/p>\r\n
\n![\"Output](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/10\/call_by_reference_output.png\")
<\/a>Output call_by_reference.ino<\/figcaption><\/figure>\n<\/div>\n The function uses the original with a different identifier. Accordingly, the variable remains changed after returning from the function.<\/p>\r\n
Passing variables by reference has the advantage that it is not necessary to create a local copy. This saves time and memory.<\/p>\r\n\n
Too many return values?<\/h4>\n\n
There is another advantage. Sometimes you want to process multiple variables in a function and use the results after returning from the function. Passing and processing are unproblematic. However, in C++ you can only return one value. We get around this problem by passing the variables by reference.<\/p>\r\n
Here is a small example:<\/p>\r\n\n
void setup() {\r\n Serial.begin(9600);\r\n int iVar_1 = 42;\r\n int iVar_2 = 4242;\r\n Serial.println(\"Original values:\");\r\n Serial.print(\"iVar_1: \"); Serial.println(iVar_1);\r\n Serial.print(\"iVar_2: \"); Serial.println(iVar_2);\r\n swap(iVar_1, iVar_2);\r\n Serial.println(\"Swapped values:\");\r\n Serial.print(\"iVar_1: \"); Serial.println(iVar_1);\r\n Serial.print(\"iVar_2: \"); Serial.println(iVar_2); \r\n}\r\n\r\nvoid loop() {\/* empty *\/}\r\n\r\nvoid swap(int &val_1, int &val_2){\r\n int temp = val_1;\r\n val_1 = val_2;\r\n val_2 = temp; \r\n}<\/pre>\r\n\nThe sketch swaps the values of two variables. This would not be possible with call-by-value. Here is the output:<\/p>\r\n
\n![\"Output](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/10\/changing_several_variables_output.png\")
<\/a>Output changing_several_variables.ino<\/figcaption><\/figure>\n<\/div>\n If you want to pass a parameter by reference, but do not want to change it in the function, then it is a good idea to prefix the parameter with the keyword
const<\/code> in the receiving function. This makes the code clearer and protects you from your own mistakes.<\/p>\r\n\n“Call-by-Pointer”<\/h3>\n\n
Alternatively, you can work in the function with a pointer to the variable to be edited. This should then be called “call-by-pointer”. However, since the term is unusual<\/strong>, I have put quotation marks around it.<\/p>\r\n
When you call the function, you prefix the parameter with the address operator. In the receiving function, the indirection operator is used:<\/p>\r\n\n
void setup() {\r\n Serial.begin(9600);\r\n int iVar = 42;\r\n Serial.print(\"iVar in Setup: \"); Serial.println(iVar);\r\n passAsPointer(&iVar);\r\n Serial.print(\"iVar in Setup: \"); Serial.println(iVar); \r\n}\r\n\r\nvoid loop() {\/* empty *\/}\r\n\r\nvoid passAsPointer(int *var){\r\n *var *= 2;\r\n Serial.print(\"Variable in passAsPointer(): \"); Serial.println(*var); \r\n}<\/pre>\r\n\nHere, too, we work with the original variable within the function. Therefore, the variable is changed permanently:<\/p>\r\n
\n![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/10\/call_by_pointer_output.png\")
<\/a>Output call-by-pointer.ino<\/figcaption><\/figure>\n<\/div>\n I would generally prefer the call-by-reference method. However, when passing arrays, we are automatically using the “call-by-pointer” method.<\/p>\r\n\n
Passing objects<\/h4>\n\n
If you pass objects as pointers and use object methods in the function, then you must use the dereference operator within the function or replace the point operator with the arrow operator. Here is an example:<\/p>\r\n\n
void setup() {\r\n Serial.begin(9600);\r\n String string = \"Hello world\";\r\n Serial.print(\"string in setup: \"); Serial.println(string);\r\n upperCase(&string);\r\n Serial.print(\"string in setup: \"); Serial.println(string);\r\n}\r\n\r\nvoid loop() {\/* empty *\/}\r\n\r\nvoid upperCase(String *localString){\r\n Serial.print(\"Upper case: \");\r\n localString->toUpperCase(); \/\/ alternative: *localString.toUpperCase;\r\n Serial.println(*localString); \r\n}<\/pre>\r\n\nAnd here is the output:<\/p>\r\n
\n![\"Output](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/10\/using_class_methods_in_function.png\")
<\/a>Output using_object_methods_in_functions.ino<\/figcaption><\/figure>\n<\/div>\n Passing arrays<\/h3>\n\n
You pass an array to a function using the name of the array as a parameter. With this, you do not pass the whole array, but only the pointer to the array. A copy of the pointer is then created in the function. As we saw earlier, the information about the size of the array, i.e. the number of elements, is lost in the process. You can conveniently calculate the size of the array via
sizeof(anyArray)\/sizeof(datatype)<\/code> and pass it as an additional parameter.<\/p>\r\n\n\r\nvoid setup() {\r\n Serial.begin(9600);\r\n int intArray[4] = {0};\r\n for(int i=0; i<4; i++){\r\n intArray[i] = i * 10;\r\n }\r\n \r\n Serial.println(\"Array in setup():\");\r\n for(int i=0; i<4; i++){\r\n Serial.print(intArray[i]); \r\n Serial.print(\" \");\r\n }\r\n Serial.println();\r\n Serial.println();\r\n \r\n doubleArray(intArray, sizeof(intArray)\/sizeof(int));\r\n \r\n Serial.println(\"Array in setup():\");\r\n for(int i=0; i<4; i++){\r\n Serial.print(intArray[i]); \r\n Serial.print(\" \");\r\n }\r\n Serial.println();\r\n Serial.println();\r\n}\r\n\r\nvoid loop() {\/* empty *\/}\r\n\r\nvoid doubleArray(int *arr, size_t count){\r\n Serial.println(\"Array in doubleArray():\");\r\n for(unsigned int i=0; i<count; i++){\r\n arr[i] *= 2;\r\n Serial.print(arr[i]); Serial.print(\" \");\r\n }\r\n Serial.println();\r\n Serial.println();\r\n}<\/pre>\r\n<\/p>\r\n<\/div>\r\n\n
Since the function works with the original, the change made by the function is permanent.<\/p>\r\n
\n![\"Output](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/10\/pass_array_output.png\")
<\/a>Output pass_array.ino<\/figcaption><\/figure>\n<\/div>\n Closing words<\/h2>\n\n
I think that with this post I have covered the most important aspects on the subject of pointers and references. But more important is what you think. So if there are any open questions or things are unclear or misunderstood, feel free to let me know. Otherwise, I hope I haven’t completely confused you with this post.<\/p>\r\n\n
Acknowledgement<\/h2>\n\n
I owe the post image to pencil parker<\/a> on Pixabay<\/a>.<\/p>\r\n","protected":false},"excerpt":{"rendered":"
Pointers and references are very useful, but equally confusing, especially for beginners. This is an attempt to bring some light into the darkness.<\/p>\n","protected":false},"author":1,"featured_media":16307,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[575],"tags":[1990,556,1987,1989,1998,1996,1993,1994,1995,1986,1984,1999,1991],"class_list":["post-17151","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-software-and-tools","tag-address-operator","tag-arduino-en-2","tag-array-en","tag-c-array-en-2","tag-call-by-reference-en-2","tag-call-by-value-en","tag-dereference-operator-en","tag-indirection-operator","tag-parameter-passing","tag-pointer-en","tag-pointers","tag-reading-an-area-of-memory","tag-reference-operator"],"yoast_head":"\n
Pointers and references • Wolles Elektronikkiste<\/title>\n<meta name=\"description\" content=\"Pointers and references are very useful, but equally confusing, especially for beginners. This is an attempt to bring some light into the darkness.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/wolles-elektronikkiste.de\/en\/pointers-and-references\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Pointers and references • Wolles Elektronikkiste\" \/>\n<meta property=\"og:description\" content=\"Pointers and references are very useful, but equally confusing, especially for beginners. This is an attempt to bring some light into the darkness.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/wolles-elektronikkiste.de\/en\/pointers-and-references\" \/>\n<meta property=\"og:site_name\" content=\"Wolles Elektronikkiste\" \/>\n<meta property=\"article:published_time\" content=\"2023-01-13T20:12:44+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2025-01-25T15:18:26+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/10\/Zeiger.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"1272\" \/>\n\t<meta property=\"og:image:height\" content=\"1200\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"Wolfgang Ewald\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Wolfgang Ewald\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"16 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en\\\/pointers-and-references#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en\\\/pointers-and-references\"},\"author\":{\"name\":\"Wolfgang Ewald\",\"@id\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en#\\\/schema\\\/person\\\/b774e4d64b4766889a2f7c6e5ec85b46\"},\"headline\":\"Pointers and references\",\"datePublished\":\"2023-01-13T20:12:44+00:00\",\"dateModified\":\"2025-01-25T15:18:26+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en\\\/pointers-and-references\"},\"wordCount\":2186,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en#\\\/schema\\\/person\\\/b774e4d64b4766889a2f7c6e5ec85b46\"},\"image\":{\"@id\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en\\\/pointers-and-references#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/wp-content\\\/uploads\\\/2022\\\/10\\\/Zeiger.jpg\",\"keywords\":[\"address operator\",\"Arduino\",\"array\",\"C array\",\"call-by-reference\",\"call-by-value\",\"dereference operator\",\"indirection operator\",\"parameter passing\",\"pointer\",\"pointers\",\"reading an area of memory\",\"reference operator\"],\"articleSection\":[\"Software and tools\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en\\\/pointers-and-references#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en\\\/pointers-and-references\",\"url\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en\\\/pointers-and-references\",\"name\":\"Pointers and references • Wolles Elektronikkiste\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en\\\/pointers-and-references#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en\\\/pointers-and-references#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/wp-content\\\/uploads\\\/2022\\\/10\\\/Zeiger.jpg\",\"datePublished\":\"2023-01-13T20:12:44+00:00\",\"dateModified\":\"2025-01-25T15:18:26+00:00\",\"description\":\"Pointers and references are very useful, but equally confusing, especially for beginners. This is an attempt to bring some light into the darkness.\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en\\\/pointers-and-references#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en\\\/pointers-and-references\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en\\\/pointers-and-references#primaryimage\",\"url\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/wp-content\\\/uploads\\\/2022\\\/10\\\/Zeiger.jpg\",\"contentUrl\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/wp-content\\\/uploads\\\/2022\\\/10\\\/Zeiger.jpg\",\"width\":1272,\"height\":1200},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en\\\/pointers-and-references#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Startseite\",\"item\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Pointers and references\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en#website\",\"url\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en\",\"name\":\"Wolles Elektronikkiste\",\"description\":\"Die wunderbare Welt der Elektronik\",\"publisher\":{\"@id\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en#\\\/schema\\\/person\\\/b774e4d64b4766889a2f7c6e5ec85b46\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":[\"Person\",\"Organization\"],\"@id\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en#\\\/schema\\\/person\\\/b774e4d64b4766889a2f7c6e5ec85b46\",\"name\":\"Wolfgang Ewald\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/wp-content\\\/uploads\\\/2019\\\/03\\\/cropped-Logo-1.png\",\"url\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/wp-content\\\/uploads\\\/2019\\\/03\\\/cropped-Logo-1.png\",\"contentUrl\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/wp-content\\\/uploads\\\/2019\\\/03\\\/cropped-Logo-1.png\",\"width\":512,\"height\":512,\"caption\":\"Wolfgang Ewald\"},\"logo\":{\"@id\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/wp-content\\\/uploads\\\/2019\\\/03\\\/cropped-Logo-1.png\"}}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Pointers and references • Wolles Elektronikkiste","description":"Pointers and references are very useful, but equally confusing, especially for beginners. This is an attempt to bring some light into the darkness.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/wolles-elektronikkiste.de\/en\/pointers-and-references","og_locale":"en_US","og_type":"article","og_title":"Pointers and references • Wolles Elektronikkiste","og_description":"Pointers and references are very useful, but equally confusing, especially for beginners. This is an attempt to bring some light into the darkness.","og_url":"https:\/\/wolles-elektronikkiste.de\/en\/pointers-and-references","og_site_name":"Wolles Elektronikkiste","article_published_time":"2023-01-13T20:12:44+00:00","article_modified_time":"2025-01-25T15:18:26+00:00","og_image":[{"width":1272,"height":1200,"url":"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/10\/Zeiger.jpg","type":"image\/jpeg"}],"author":"Wolfgang Ewald","twitter_card":"summary_large_image","twitter_misc":{"Written by":"Wolfgang Ewald","Est. reading time":"16 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/wolles-elektronikkiste.de\/en\/pointers-and-references#article","isPartOf":{"@id":"https:\/\/wolles-elektronikkiste.de\/en\/pointers-and-references"},"author":{"name":"Wolfgang Ewald","@id":"https:\/\/wolles-elektronikkiste.de\/en#\/schema\/person\/b774e4d64b4766889a2f7c6e5ec85b46"},"headline":"Pointers and references","datePublished":"2023-01-13T20:12:44+00:00","dateModified":"2025-01-25T15:18:26+00:00","mainEntityOfPage":{"@id":"https:\/\/wolles-elektronikkiste.de\/en\/pointers-and-references"},"wordCount":2186,"commentCount":0,"publisher":{"@id":"https:\/\/wolles-elektronikkiste.de\/en#\/schema\/person\/b774e4d64b4766889a2f7c6e5ec85b46"},"image":{"@id":"https:\/\/wolles-elektronikkiste.de\/en\/pointers-and-references#primaryimage"},"thumbnailUrl":"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/10\/Zeiger.jpg","keywords":["address operator","Arduino","array","C array","call-by-reference","call-by-value","dereference operator","indirection operator","parameter passing","pointer","pointers","reading an area of memory","reference operator"],"articleSection":["Software and tools"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/wolles-elektronikkiste.de\/en\/pointers-and-references#respond"]}]},{"@type":"WebPage","@id":"https:\/\/wolles-elektronikkiste.de\/en\/pointers-and-references","url":"https:\/\/wolles-elektronikkiste.de\/en\/pointers-and-references","name":"Pointers and references • Wolles Elektronikkiste","isPartOf":{"@id":"https:\/\/wolles-elektronikkiste.de\/en#website"},"primaryImageOfPage":{"@id":"https:\/\/wolles-elektronikkiste.de\/en\/pointers-and-references#primaryimage"},"image":{"@id":"https:\/\/wolles-elektronikkiste.de\/en\/pointers-and-references#primaryimage"},"thumbnailUrl":"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/10\/Zeiger.jpg","datePublished":"2023-01-13T20:12:44+00:00","dateModified":"2025-01-25T15:18:26+00:00","description":"Pointers and references are very useful, but equally confusing, especially for beginners. This is an attempt to bring some light into the darkness.","breadcrumb":{"@id":"https:\/\/wolles-elektronikkiste.de\/en\/pointers-and-references#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/wolles-elektronikkiste.de\/en\/pointers-and-references"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/wolles-elektronikkiste.de\/en\/pointers-and-references#primaryimage","url":"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/10\/Zeiger.jpg","contentUrl":"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/10\/Zeiger.jpg","width":1272,"height":1200},{"@type":"BreadcrumbList","@id":"https:\/\/wolles-elektronikkiste.de\/en\/pointers-and-references#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Startseite","item":"https:\/\/wolles-elektronikkiste.de\/en"},{"@type":"ListItem","position":2,"name":"Pointers and references"}]},{"@type":"WebSite","@id":"https:\/\/wolles-elektronikkiste.de\/en#website","url":"https:\/\/wolles-elektronikkiste.de\/en","name":"Wolles Elektronikkiste","description":"Die wunderbare Welt der Elektronik","publisher":{"@id":"https:\/\/wolles-elektronikkiste.de\/en#\/schema\/person\/b774e4d64b4766889a2f7c6e5ec85b46"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/wolles-elektronikkiste.de\/en?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":["Person","Organization"],"@id":"https:\/\/wolles-elektronikkiste.de\/en#\/schema\/person\/b774e4d64b4766889a2f7c6e5ec85b46","name":"Wolfgang Ewald","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2019\/03\/cropped-Logo-1.png","url":"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2019\/03\/cropped-Logo-1.png","contentUrl":"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2019\/03\/cropped-Logo-1.png","width":512,"height":512,"caption":"Wolfgang Ewald"},"logo":{"@id":"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2019\/03\/cropped-Logo-1.png"}}]}},"_links":{"self":[{"href":"https:\/\/wolles-elektronikkiste.de\/en\/wp-json\/wp\/v2\/posts\/17151","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/wolles-elektronikkiste.de\/en\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/wolles-elektronikkiste.de\/en\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/wolles-elektronikkiste.de\/en\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/wolles-elektronikkiste.de\/en\/wp-json\/wp\/v2\/comments?post=17151"}],"version-history":[{"count":2,"href":"https:\/\/wolles-elektronikkiste.de\/en\/wp-json\/wp\/v2\/posts\/17151\/revisions"}],"predecessor-version":[{"id":23042,"href":"https:\/\/wolles-elektronikkiste.de\/en\/wp-json\/wp\/v2\/posts\/17151\/revisions\/23042"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/wolles-elektronikkiste.de\/en\/wp-json\/wp\/v2\/media\/16307"}],"wp:attachment":[{"href":"https:\/\/wolles-elektronikkiste.de\/en\/wp-json\/wp\/v2\/media?parent=17151"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/wolles-elektronikkiste.de\/en\/wp-json\/wp\/v2\/categories?post=17151"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/wolles-elektronikkiste.de\/en\/wp-json\/wp\/v2\/tags?post=17151"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
- Pass arrays<\/a><\/li>\r\n<\/ul>\r\n<\/li>\r\n<\/ul>\r\n\n
- “Call-by-Pointer”<\/a>\r\n
- Call-by-Reference<\/a>\r\n
- A simple example<\/a><\/li>\r\n