blob: ec2dea6d7ed047fded88b42462d98f505132c774 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
|
.. highlight:: cpp
.. _lang-sizeof:
``sizeof()``
============
The ``sizeof`` operator on the Maple returns the number of bytes
needed to store a value of a given type\ [#fcharsize]_. This can be
an ordinary numeric type, like ``int``. It can be something more
complicated, like a ``struct`` or ``union``. If the argument to
``sizeof`` is an array, it returns the total number of bytes occupied
by the array.
The general syntax looks like this::
sizeof(type)
sizeof(var)
Example
-------
The ``sizeof`` operator is useful for dealing with arrays (such as
strings) where it is convenient to be able to change the size of the
array without breaking other parts of the program.
This program prints out a text string one character at a time. Try
changing the text phrase::
char myStr[] = "this is a test";
int i;
void setup() {
Serial.begin(9600);
}
void loop() {
for (i = 0; i < sizeof(myStr) - 1; i++) {
Serial.print(i, DEC);
Serial.print(" = ");
Serial.println(myStr[i], BYTE);
}
}
Note that ``sizeof`` returns the total number of bytes. So for larger
variable types such as ``int``, the :ref:`for loop <lang-for>`
would look something like this::
for (i = 0; i < (sizeof(myInts)/sizeof(int)) - 1; i++) {
// do something with myInts[i]
}
.. rubric:: Footnotes
.. [#fcharsize] Technically (and pedantically) speaking, ``sizeof``
returns a multiple of the number of bits a ``char`` occupies in
memory. However, on the Maple (this goes for most C++
implementations), a ``char`` occupies 8 bits = 1 byte. All the C++
standard guarantees, however, is that a ``char`` occupies at
*least* 8 bits.
.. include:: /arduino-cc-attribution.txt
|
