Bar: /* Referencer */

2022-11-24T13:19:12Z

Referencer

← Ældre version		Versionen fra 24. nov. 2022, 15:19
Linje 224:		Linje 224:
	==Referencer==		==Referencer==
	<references />		<references />

			{{Programmering}}


	[[Kategori:Grundlæggende_C]]		[[Kategori:Grundlæggende_C]]

Bar: /* word */

2022-11-15T20:20:26Z

word

← Ældre version		Versionen fra 15. nov. 2022, 22:20
Linje 79:		Linje 79:
	===word===		===word===
	Er samme type som unsigned int, altså 2 byte der rummer tal fra 0 til 65535.		Er samme type som unsigned int, altså 2 byte der rummer tal fra 0 til 65535.

			===unsigned long===
			I Arduino er den 4 byte og rummer tal fra 0 til 4.294.967.295

			I Processing er dem 8 byte og rummer tal fra 0 til 18.446.744.073.709.551.615

	==Tal-typer med decimaler==		==Tal-typer med decimaler==

Bar: /* long */

2022-11-15T20:18:15Z

long

← Ældre version		Versionen fra 15. nov. 2022, 22:18
Linje 70:		Linje 70:

	===long===		===long===
	I Arduino er det en 4 byte heltal, som kan rumme heltal fra		I Arduino er det en 4 byte heltal, som kan rumme heltal fra -2.147.483.648 til 2.147.483.647.

			I Processing er det en 8 byte heltal, som kan rumme tal fra -9.223.372.036.854.775.808 til 9.223.372.036.854.775.807

	===unsigned int===		===unsigned int===

Bar: /* short */

2022-11-15T20:16:47Z

short

← Ældre version		Versionen fra 15. nov. 2022, 22:16
Linje 68:		Linje 68:

	I Processing (nedarvet fra java) har short det samme område som Arduinos int (-32768 - 32767) og ikke 4 bytes området som int ellers har i processeing		I Processing (nedarvet fra java) har short det samme område som Arduinos int (-32768 - 32767) og ikke 4 bytes området som int ellers har i processeing

			===long===
			I Arduino er det en 4 byte heltal, som kan rumme heltal fra

	===unsigned int===		===unsigned int===

Bar: /* int */

2022-11-15T20:15:42Z

int

← Ældre version		Versionen fra 15. nov. 2022, 22:15
Linje 62:		Linje 62:
	Er også en variabel til heltal, men består i Arduino af to bytes, og kan derfor indeholde tal fra -32768 til 32767.		Er også en variabel til heltal, men består i Arduino af to bytes, og kan derfor indeholde tal fra -32768 til 32767.

	I andre varianter af C lagres en int som 4 bytes og svarer til Arduinos long-type.		I andre varianter af C og i Processing lagres en int som 4 bytes og svarer til Arduinos long-type.

	===short===		===short===

Bar: 1 version importeret

2022-10-26T04:45:12Z

1 version importeret

← Ældre version	Versionen fra 26. okt. 2022, 06:45
(Ingen forskel)

htx_>Bar: /* array */

2021-09-21T12:34:22Z

array

Ny side

I ethvert sprog skal man overveje hvilke typer det er man lagrer sine variabler i, om det er tekst, tal, decimal-tal osv.

For typesvage sprog som [[javaScript]] betyder det ikke så meget, da variabler kan ændre type undervejs i afviklingen af programmet, men nogle steder vil noget man tolker som en matematisk beregning kunne blive opfattet som streng-operationer, således at regnestykket 2+2 giver 22 i stedet for 4.

For typestærke sprog som C (fx Arduinos C), så vil compileren nægte at oversætte koden, hvis man forsøger at lægge en streng til et heltal.

==Oversigt==
{|class="wikitable"
|-
!Type!!Størrelse Arduino!!Område Arduino!!Størrelse Processing!!Område Processing
|-
|void||0 byte|| -||0 byte|| -
|-
|boolean||1 byte||0 - 1 / false - true||1 byte||0 - 1 / false - true
|-
|char||1 byte||-128 - 127||1 byte||-128 - 127
|-
|unsigned char<br />byte||1 byte||0 - 255||1 byte||0 - 255
|-
|int<br />short||2 byte||-32.768 - 32.767||4 byte||-2.147.483.648 - 2.147.483.647<br />short er -32.768 - 32.767
|-
|unsigned int<br />word||2 byte||0 - 65.535||4 byte||0 - 4.294.967.295
|-
|long||4 byte||-2.147.483.648 - 2.147.483.647||8 byte||-9.223.372.036.854.775.808 - 9.223.372.036.854.775.807
|-
|unsigned long||4 byte ||0 - 4.294.967.295||8 byte||0 - 18.446.744.073.709.551.615
|-
|[[float]]||4 byte||+/- 1,2e-38 - 3,4e38 6-7 betydende cifre||4 byte||+/- 1,2e-38 - 3,4e38 6-7 betydende cifre
|-
|[[C_double|double]]||4 byte||+/- 1,2e-38 - 3,4e38 6-7 betydende cifre||8 byte||2,2e-38 - 1,8e308 16 betydende cifre
|-
|string||lgd+1 byte||tekst||lgd+1 bytes||tekst
|-
|String||større||tekst||større||tekst
|}

==Specielle variabeltyper==
===void===
Void er ikke en egentlig type, men hører stadig med under kategorien, fordi den anvendes i forbindelse med typeerklæringer.

void betyder tomrum eller ingenting, og det er lige netop det som det udtrykker i den sammenhæng - void anvendes til typeerklæringer af funktioner, hvor man angiver at funktionen ikke kan returnere noget.

===boolean===
logisk variabel, der kan antage værdierne falsk eller sand (false / true) eller low / high, OFF / ON, 0 / 1.

Typemæssigt kan den rummes i en bit, men i praksis lagres den i en byte for at gøre det lettere at adressere den.

==Heltals typer==

===char===
Umiddelbart så er char-typen anvendelig til at indeholde en karakter, altså fx 'A', men da alle karakterer er defineret ved hjælp af tal ud fra [[ASCII]]-tabellen, så er den også defineret som et heltal.

Tal-området for char går fra -128 til 127, da en char ligger lagret i én byte.

===unsigned char===
En unsigned char er igen til små heltal, men her er talområdet 0-255, igen begrænset af at den ligger i en byte.

===byte===
Er den samme type som en unsigned char.

===int===
Er også en variabel til heltal, men består i Arduino af to bytes, og kan derfor indeholde tal fra -32768 til 32767.

I andre varianter af C lagres en int som 4 bytes og svarer til Arduinos long-type.

===short===
Er det samme som en int i Arduino.

I Processing (nedarvet fra java) har short det samme område som Arduinos int (-32768 - 32767) og ikke 4 bytes området som int ellers har i processeing

===unsigned int===
Er i Arduino igen 2 bytes og uden fortegn, så talområdet dækker fra 0 til 65535.

===word===
Er samme type som unsigned int, altså 2 byte der rummer tal fra 0 til 65535.

==Tal-typer med decimaler==
===[[float]]===
Type på 4 bytes, der kan indeholde decimal-tal. Se den mere tekniske beskrivelse under [[float]].

===[[C_double|double]]===
Type på 8 bytes, der kan indeholde decimal-tal. Se den mere tekniske beskrivelse under [[C_double|double]].

OBS - i [[Arduino UNO]] kan man godt lave programmer der indeholder double, men typen falder blot tilbage til en float, så man får ikke den ønskede præcision. Her skal man over i fx en [[Arduino Due]], som er baseret på en 32 bit processor.

==Sammensatte variabler==
===string===
En måde at gemme en tekststreng på er ved at oprette et array af char<ref name="charString">[https://www.arduino.cc/reference/en/language/variables/data-types/string/ char-string] i Arduino reference</ref> som vist her:

<source lang="C">
char str[] = "Hallo, world!";
</source>

Dette opretter et char array på 14 karakterer, altså de 13 karakterer der er i tekst-strengen og en 0-karakter til at angive slutningen af strengen. Hvis man ønsker at kunne udvide strengen, så skal man erklære den maksimale størrelse som vist her:

<source lang="C">
char str[32] = "Hallo, world!";
</source>

Denne streng kan så maksimalt indeholde 31 karakterer, da der også skal være plads til 0-karakteren for at afslutte.

===String===
En anden måde at gemme en tekststreng på er ved at oprette en variabel af typen String<ref name="stringObj">[https://www.arduino.cc/reference/en/language/variables/data-types/stringobject/ String-object] i Arduino Reference</ref> som vist her:

<source lang="C">
String str = "Hallo, world!";
</source>

Dette opretter et objekt, der indeholder 13 karakterer. Typen er mere fleksibel og den kan udvides uden problemer, så længe der er hukommelse nok, den har til gengæld den ulempe at den bruger mere hukommelse som illustreret i næste afsnit.

====Sammenligning mellem string og String i Arduino C====

Denne sammenligning går på forbruget af hukommelse ved anvendelsen af de to datatyper. Man kunne også sammenligne afviklingstiden, hvis man ønskede det.

For kunne måle forbruget af hukommelse anvendes et bibliotek MemoryFree<ref>[https://github.com/maniacbug/MemoryFree MemoryFree] bibliotek ved GitHub</ref>, der er henvist til fra Arduinos Playgound<ref>[https://playground.arduino.cc/Code/AvailableMemory Available memory] omtalt på Arduinos hjemmeside</ref>.

Når biblioteket er indlæst kan man afvikle følgende kode:
<source lang="C">
#include <MemoryFree.h>

// Reported free memory with str commented out:
// 1805 bytes
//
// Reported free memory with just str as char array uncommented
// 1805 bytes
// No difference - the compiler opimizes, beqause str is not used
//
// Reported free memory with str and Serial.println(str) uncommented:
// 1791
// Difference: 14 bytes (13 ascii chars + null terminator
//
// Reported free memory with str as String uncommented and used in println
// 1763
// Difference: 42 bytes (13 ascii chars, and 29 of overhead for administration)
//
// Reported free memory with str and str2 as String uncommented and used in println
// 1746
// Extra: 7 bytes (4 ascii chars, and further 3 of overhead for pointer)

// 14-bytes string as char array
char str[] = "Hallo, world!";

// 14-bytes String
// String str = "Hallo, world!";
// String str2 = "Test";

void setup() {
Serial.begin(115200);
}

void loop() {
// Serial.print(str2);
Serial.println(str);

Serial.print("freeMemory()=");
Serial.println(freeMemory());

delay(1000);
}
</source>

Koden kan hentes i følgende [[media:memoryFree.zip|ZIP-fil]].

Testen angiver hvor meget hukommelse der anvendes, hvor char-arrayet<ref name="charString" /> anvende en byte ud over selve indholdet i strengen, så det er en fordel, hvis man har knebent med plads (hvilket let kan være tilfældet med de 2 kB som Arduino UNO har til rådighed). Hvis man ikke har de store krav, så kan man lige så godt anvende den objektbaserede String, men den sluger noget mere hukommelse, specielt ved de første definitioner.

En ulempe ved det char-baserede array er at man kun har en fast størrelse, som man skal fastlægge ved compileringen. Forsøger man at gå ud over dette, så vil man skrive videre med over andre variabler, uden at man får nogen advarsler.

Fordelen ved det objektorienterede er at man frit kan manipulere videre med teksterne, men det kan hurtigt koste ekstra hukommelse, og det kan være svært at optimere på hvordan man gør det med mindst forbrug af hukommelse - det afhænger af hvordan man manipulerer videre, og hvor godt String-biblioteket<ref name="stringObj" /> håndterer pakning og oprydning i hukommelsen.

===array===
Et array er en samling af variabler af en bestemt type i et navn.

Arrayet kan håndteres som en variabel, men det smarte er at man kan indeksere de enkelte variabler i arrayet.

I standard C har et array en fast størrelse, og det indekseres fra 0 og op til længden-1.

Et eksempel på hvordan man kan arbejde med et array er givet her:

<source lang="C">
int ligeTal[10];

for (int n=0; n < 10; n++) {
ligeTal[n] = (n + 1) * 2;
}
</source>
Koden gør det at der erklæres et array man plads til 10 heltal, der er udefinerede.

I loopet løbes n igennem fra 0 til og med 9. Inde i loopet beregnes de lige tal ved at gange tælleren plus en med 2, så det første tal bliver 2, det næste 4 og det sidste tal (med indeks 9) bliver 20.

Læg mærke til at variablen ligeTal har [n] stående efter sig, for at indeksere hvilken en af de 10 variabler der bliver skrevet til.

Når man har elementer i arrayet, så kan man behandle dem enkeltvis og som her trække alle elementer ud som udskrift:

<source lang="C">
for (int n=0; n < 10; n++) {
Serial.print("Element ");
Serial.print(n);
Serial.print(" ");
Serial.println(ligeTal[n]);
}
</source>

Man kan også lave beregninger på indholdet, som her hvor man finder gennemsnittet af alle elementer i arrayet:

<source lang="C">
int sum = 0;
for (int n=0; n < 10; n++) {
sum = sum + ligeTal[n];
}
float gennemsnit = (float)sum / 10.0;
</source>

==Referencer==
<references />

[[Kategori:Grundlæggende_C]]