I programmering er **udefinert åtferd** resultatet av å køyra kode som ikkje har ei åtferd definert av språkspesifikasjonen som koden er stilt til. Både C og C++ er språk der åtferda stundom er udefinert. I standarden til desse språka står semantikken for enkelte operasjonar som udefinert. Ein kompilator har lov til å gå ut i frå at slike operasjonar aldri vil oppstå i koden. Implementasjonen av kompilatoren vil vera oppfatta som korrekt uansett kva han definerer åtferda til å vera for dei tilfella der kode har udefinert åtferd. Dette gjev stor fleksibilitet for dei som skal skriva kompilatorar, ettersom det ofte tillèt kompilatoren å gjera store optimiseringar. Det er ansvaret til programvareutviklaren å skriva kode som ikkje har udefinert åtferd, sjølv om kompilatoren har lov til å diagnostisera problemet når det skjer.

Døme på udefinert åtferd
------------------------

Det å modifisera eit «string literal» er udefinert åtferd 

```
char \*p = "wikipedia";
p[0] = 'W'; // Dette er udefinert åtferd

```
Heiltalsdivisjon med 0 er òg udefinert oppførsel 

```
int res = 5/0;

```
Det å endra eit objekt fleire gongar mellom to sekvenspunkt er òg udefinert åtferd. Eit sekvenspunkt er eit punkt i programmet der alle sideeffektar ved tidlegare evalueringar skal gjennomførast og ingen sideffektar av kommande evalueringar skal ha hendt. Eit semikolon er eit døme på eit sekvenspunkt. Det er verdt å nemna at her er det visse skilnadar mellom C og C++ på kva som er udefinert åtferd i samsvar med sekvenspunkt, spesielt etter versjonsstandarden C++11. Men dette særskilde høvet vil vera udefinert åtferd i begge. 

```
int i = 5;
i = i++ + 1; // Dette er udefinert åtferd

```
Når ein modifiserer eit objekt mellom to sekvenspunkt vil òg det å lesa verdien for noko anna føremål enn å avgjera verdien som skal lagrast vera udefinert åtferd. I det første dømet gjeld det variabelen i, som vert lesen i «a[i]» men for eit anna føremål enn å avgjera verdien til i. Mellom sekvenspunkta vert òg verdien av i endra, som vidare fører til udefinert åtferd. Ein kan sjå same prinsipp ved dømet i andre linje.

```
a[i] = i++; // udefinert åtferd
printf("%d %d", ++n, power(2, n)); // også udefinert åtferd

```
Visse peikaroperasjonar er òg udefinert åtferd 

```
int arr[4] = {1, 2, 3, 4};
int \*p = arr + 5; // Dette er udefinert åtferd

```
Det å nå enden av eit funksjonskall som skal returnera ein verdi er òg udefinert åtferd 

```
int funk() {

}

printf("%d", funk()); // udefinert åtferd

```

Referansar
----------

1. 1 2  «Order of evaluation - cppreference.com». *en.cppreference.com*. Henta 9. august 2016.
2. ↑  ISO/IEC (2003). *ISO/IEC 14882:2003(E): Programming Languages - C++ §2.13.4 String literals [lex.string]* para. 2
3. ↑  ANSI X3.159-1989 *Programming Language C*, footnote 26
4. ↑  ISO/IEC (1999). *ISO/IEC 9899:1999(E): Programming Languages - C §6.5 Expressions* para. 2
5. ↑  ISO/IEC (2003). *ISO/IEC 14882:2003(E): Programming Languages - C++ §5.7 Additive operators [expr.add]* para. 5
6. ↑  ISO/IEC (2007). *ISO/IEC 9899:2007(E): Programming Languages - C §6.9 External definitions* para. 1

* *Denne artikkelen bygger på «Udefinert oppførsel» frå Wikipedia på bokmål, den 21. august 2020.*