제어 흐름

**제어 흐름**()은 실행이 한 명령어에서 다음 명령어로 진행되는 방식을 설명한다. 기계어나 명령형 프로그래밍 프로그래밍 언어와 같은 많은 문맥에서, 명령어가 제어를 다른 지점으로 전달하는 경우를 제외하면 제어는 순차적으로(현재 실행 중인 명령어 직후에 위치한 명령어로) 진행되며, 이 경우 해당 명령어를 제어 흐름 명령어라고 분류한다.  문맥에 따라 명령어 대신 다른 용어가 사용되기도 한다. 예를 들어 기계어에서는 일반적인 용어가 인스트럭션(instruction)이며, 명령형 언어에서는 스테이트먼트(statement, 구문)라는 용어가 일반적이다.

명령형 언어는 제어 흐름을 명시적으로 인코딩하지만, 다른 프로그래밍 패러다임의 언어들은 제어 흐름에 덜 집중한다. 선언형 프로그래밍 언어는 연산 순서를 규정하지 않고 원하는 결과를 지정한다. 함수형 프로그래밍 언어는 일반적으로 제어 흐름 구문이라고 부르지는 않지만, 흐름을 제어하기 위해 언어 구조와 함수를 모두 사용한다.

중앙 처리 장치의 인스트럭션 세트에서 제어 흐름 인스트럭션은 종종 프로그램 카운터를 변경하며, 무조건적인 분기(점프라고도 함) 또는 조건부 분기 중 하나다. 대안적인 접근 방식은 분기 대신 조건에 따라 인스트럭션을 활성화하는 술어화(predication)이다.

인터럽트나 신호와 같은 비동기 제어 흐름 전달은 제어가 중단된 지점으로 돌아가기 전에 일반적인 제어 흐름을 핸들러로 변경한다.

소프트웨어를 공격하는 한 가지 방법은 실행 흐름을 리다이렉션하는 것이다. 스택 카나리, 버퍼 오버플로 보호, 섀도우 스택, vtable 포인터 검증을 포함한 다양한 제어 흐름 무결성 기술이 이러한 공격을 방어하는 데 사용된다.

## 구조
제어 흐름은 코드 구조와 밀접하게 관련되어 있다. 제어는 언어의 구조와 실행 규칙에 의해 정의된 라인을 따라 흐른다. 이 일반적인 구조 개념은 구조를 블록 조직에 기반한 순차, 선택 및 반복으로 제한하는 구조적 프로그래밍과 혼동해서는 안 된다.

### 순차
순차적 실행은 가장 기본적인 구조다. 모든 코드가 본질적으로 순차적인 것은 아니지만, 명령형 코드는 순차적이다.

### 레이블
레이블은 소스 코드 내의 위치를 식별한다. 일부 제어 흐름 구문은 제어가 레이블이 지정된 라인으로 점프하도록 레이블을 참조한다. 위치를 표시하는 것 외에 레이블은 다른 효과가 없다.

일부 언어에서는 레이블을 숫자로 제한하며, 이를 때로는 줄 번호라고 부른다. 다만 줄 번호는 레이블이라기보다는 해당 행의 고유한 인덱스를 의미한다. 그럼에도 불구하고, 이러한 숫자 레이블은 순차적이지 않더라도 일반적으로 파일 내에서 위에서 아래로 증가해야 한다. 예를 들어 BASIC에서는 다음과 같다.


```qbasic
10 LET X = 3
20 PRINT X
30 GOTO 10
```


많은 언어에서 레이블은 영숫자 식별자이며, 보통 행의 시작 부분에 나타나고 바로 뒤에 콜론이 붙는다. 예를 들어, 다음 C 코드는 3행에  레이블을 정의하며, 이는 그 뒤에 오는 첫 번째 구문(4행)을 점프 대상 지점으로 식별한다.


```c
void f(bool ok) {
    if (ok) {
        goto success;
    }
    return;
success:
    printf("OK");
}
```


### 블록
대부분의 언어는 코드 시퀀스를 블록으로 구성하는 기능을 제공한다. 제어문과 함께 사용될 때, 블록의 시작 부분은 점프 대상이 된다. 예를 들어, 중괄호를 사용하여 블록을 구분하는 다음 C 코드에서 이 거짓이면 제어는 1행에서 4행으로 점프한다.


```c
if (done) {
    printf("All done");
} else {
    printf("Still workin' on it");
}
```


## 제어

프로그래밍 언어를 위해 많은 제어 명령어가 고안되었다. 이 섹션은 주목할 만한 구조들을 기능별로 정리하여 설명한다.

### 함수
함수는 제어 흐름을 제공하며, 함수가 호출되면 실행은 함수 코드의 시작 부분으로 점프하고, 완료되면 제어는 호출 지점으로 돌아간다. 다음 C 코드에서 제어는  함수를 호출하기 위해 6행에서 2행으로 점프한다. 그 후, 함수 본문을 완료("Hi" 출력)한 후, 제어는 호출 이후인 7행으로 돌아간다.


```c
void foo() {
    printf("Hi");
}

void bar() {
    foo();
    printf("Done");
}
```


### 분기
분기 명령어는 실행 지점을 명령어가 포함된 코드 지점에서 명령어가 지정하는 지점으로 이동시킨다.

#### 점프
점프 명령어는 코드의 다른 지점으로 무조건 제어를 분기하며, 코드 흐름을 제어하는 가장 기본적인 형태다.

고급 언어에서는 이것이 종종 goto 구문으로 제공된다. 언어에 따라 키워드가 대문자나 소문자일 수 있고, 한 단어 혹은 두 단어일 수 있지만 보통 `goto label`과 같은 식이다. 제어가 goto 구문에 도달하면, 제어는 표시된 레이블 뒤의 구문으로 점프한다. goto 구문은 데이크스트라를 포함한 많은 컴퓨터 과학자들에 의해 해로운 것으로 간주되어 왔다.

#### 조건부 분기
조건문은 불리언 표현식의 값에 따라 제어를 점프시킨다. 일반적인 변형은 다음과 같다.

; if-goto: 조건에 따라 레이블로 점프한다. 유사하게 사용되는 기계어 인스트럭션을 밀접하게 모방한 고급 프로그래밍 구문이다.

; if-then: 점프에 국한되지 않고, 표현식이 참이면 구문이나 블록이 실행된다.  키워드를 포함하지 않는 언어에서는 이를 if 구문이라고 부를 수 있다.

; if-then-else: if-then과 같지만, 조건이 거짓일 때 수행할 두 번째 동작이 있다.  키워드를 포함하지 않는 언어에서는 이를 if-else 구문이라고 부를 수 있다.

; 중첩(Nested): 조건문은 종종 다른 조건문 내에 중첩된다.

; 산술 if: 초기 포트란에는 숫자 값이 음수, 0, 또는 양수인지 테스트하는 산술 if(arithmetic if, 일명 3방향 if)가 있었다. 이 구문은 Fortran-90에서 시대에 뒤떨어진 것으로 간주되었고, Fortran 2018부터 삭제되었다.

; 연산자: 일부 언어는 삼항 조건 연산자와 같은 연산자 형태를 가진다.

; when 및 unless: 펄은 C 스타일의 를  및 로 보완한다.

; 메시지: 스몰토크는 언어 구조 대신 `ifTrue`와 `ifFalse` 메시지를 사용하여 조건문을 구현한다.

다음 파스칼 코드는 간단한 if-then-else를 보여준다. 구문은 에이다에서도 유사하다.


```pascal
if a > 0 then
  writeln("yes")
else
  writeln("no");
```


C에서:


```c
if (a > 0) {
    puts("yes");
} else {
    puts("no");
}
```


배시에서:


```bash
if [ $a -gt 0 ]; then
      echo "yes"
else
      echo "no"
fi
```


파이썬에서:


```python
if a > 0:
    print("yes")
else:
    print("no")
```


리스프에서:


```lisp
(princ
  (if (plusp a)
      "yes"
      "no"))
```


#### 다방향 분기
다방향 분기는 일치하는 값에 따라 제어를 점프시킨다. 보통 일치하는 항목이 없을 경우를 대비한 기본 동작 규정이 있다. switch 구문은 순람표와 같은 컴파일러 최적화를 허용할 수 있다. 동적 언어에서 사례(case)는 상수 표현식에 국한되지 않을 수 있으며, 오른쪽의 셸 스크립트 예제와 같이 글로브를 사용하여 모든 문자열과 일치하는 기본 사례를 구현하는 `*)`와 같은 패턴 매칭으로 확장될 수 있다. 사례 로직은 SQL의 `decode` 구문과 같이 함수 형태로 구현될 수도 있다.

다음 파스칼 코드는 비교적 간단한 switch 구문을 보여준다. 파스칼은  대신  키워드를 사용한다.


```pascal
case someChar of
  'a': actionOnA;
  'x': actionOnX;
  'y','z':actionOnYandZ;
  else actionOnNoMatch;
end;
```


에이다에서:


```ada
case someChar is
  when 'a' => actionOnA;
  when 'x' => actionOnX;
  when 'y' | 'z' => actionOnYandZ;
  when others => actionOnNoMatch;
end;
```


C에서:


```c
switch (someChar) {
    case 'a':
        actionOnA;
        break;
    case 'x':
        actionOnX;
        break;
    case 'y':
    case 'z':
        actionOnYandZ;
        break;
    default:
        actionOnNoMatch;
}
```


배시에서:


```bash
case $someChar in
   a)    actionOnA ;;
   x)    actionOnX ;;
   [yz]) actionOnYandZ ;;
   *)    actionOnNoMatch  ;;
esac
```


리스프에서:


```lisp
(case some-char
  ((#\a)     action-on-a)
  ((#\x)     action-on-x)
  ((#\y #\z) action-on-y-and-z)
  (else      action-on-no-match))
```


포트란에서:


```fortran
select case (someChar)
  case ('a')
    actionOnA
  case ('x')
    actionOnX
  case ('y','z')
    actionOnYandZ
  case default
    actionOnNoMatch
end select
```


### 루프
섬네일|프로그램 루프의 기본 유형
루프는 런타임 상태에 따라 여러 번 실행되는 구문의 시퀀스인 루프 본문이다. 본문은 컬렉션의 각 항목에 대해 한 번씩(확정적 반복), 조건이 충족될 때까지(비확정적 반복), 또는 무한히 실행된다. 루프 본문 내부의 루프를 중첩 루프라고 한다. 루프에서의 조기 종료는 break 구문을 통해 지원될 수 있다.

하스켈 및 스킴과 같은 함수형 프로그래밍 언어에서 재귀적 및 반복적 프로세스는 구문적인 루프 구조 대신 꼬리 재귀 프로시저로 표현된다.

#### 숫자 기반

비교적 단순하면서도 유용한 루프는 일정 범위의 숫자 값을 반복한다. 단순한 형태는 정수 값에서 시작하여 더 큰 정수 값에서 끝나며 그 사이의 각 정수 값에 대해 반복한다. 종종 증감분은 임의의 정수 값(더 큰 값에서 작은 값으로 루프하기 위해 음수일 수도 있음)이 될 수 있다.

BASIC에서의 예:


```basic
FOR I = 1 TO N
   xxx
NEXT I
```


파스칼에서의 예:


```pascal
for I := 1 to N do begin
   xxx
end;
```


포트란에서의 예:


```fortran
DO I = 1,N
    xxx
END DO
```


많은 프로그래밍 언어에서 정수만 사용하거나 정수만이 신뢰 가능하다. 부동 소수점 숫자는 하드웨어 제약으로 인해 부정확하게 표현되므로, 다음 루프는 반올림 오류, 하드웨어, 컴파일러와 같은 다양한 요인에 따라 9번 또는 10번 반복될 수 있다. 또한, X의 증가가 반복적인 덧셈에 의해 발생하는 경우 누적된 반올림 오류는 각 반복에서 X의 값이 일반적으로 예상되는 0.1, 0.2, 0.3, ..., 1.0 시퀀스와 상당히 다를 수 있음을 의미한다.

 **for** X := 0.1 **step** 0.1 **to** 1.0 **do**

#### 조건 제어형

일부 루프 구조는 조건이 참일 때까지 반복한다. 일부 변형은 루프 시작 부분에서 조건을 테스트하고, 다른 것들은 끝에서 테스트한다. 시작 부분에서 테스트하는 경우 본문을 완전히 건너뛸 수 있다. 끝에서 테스트하는 경우 본문은 항상 적어도 한 번 실행된다.

Visual Basic에서의 예:


```visualbasic
DO WHILE (test)
    xxx
LOOP
```


파스칼에서의 예:


```pascal
repeat
    xxx
until test;
```


C 계열의 선행 테스트(pre-test) 예:


```c
while (test) {
    xxx
}
```


C 계열의 후행 테스트(post-test) 예:


```c
do
    xxx
while (test);
```


 키워드를 사용하더라도 3개 부분으로 구성된 C 스타일 루프는 숫자 기반이 아닌 조건 기반 구조다. 두 번째 부분인 조건은 각 루프 전에 평가되므로 루프는 선행 테스트 방식이다. 첫 번째 부분은 상태를 초기화하는 장소이고, 세 번째 부분은 다음 반복을 위해 증감하는 곳이지만, 두 측면 모두 다른 곳에서 수행될 수 있다. 다음 C 코드는 i가 0에서 n-1까지 반복되는 숫자 루프의 로직을 구현한다.


```c
for (int i = 0; i < n; ++i) {
    xxx
}
```


#### 열거형

일부 루프 구조는 컬렉션의 항목을 열거하여 각 항목에 대해 반복한다.

스몰토크에서의 예:


```smalltalk
someCollection do: [:eachElement |xxx].
```


파스칼에서의 예:


```pascal
for Item in Collection do begin xxx end;
```


Raku에서의 예:


```raku
foreach (item; myCollection) { xxx }
```


TCL에서의 예:


```tcl
foreach someArray { xxx }
```


PHP에서의 예:


```php
foreach ($someArray as $k => $v) { xxx }
```


자바에서의 예:


```java
Collection<String> coll;
for (String s : coll) {}
```


C#에서의 예:


```csharp
foreach (string s in myStringCollection) { xxx }
```


'foreach'가 'ForEach-Object'의 별칭인 파워셸에서의 예:


```powershell
someCollection | foreach { $_ }
```


포트란에서의 예:


```fortran
forall ( index = first:last:step... )
```


스칼라에는 컬렉션 제어 루프를 일반화하고 비동기 프로그래밍과 같은 다른 용도도 지원하는 for-표현식(for-expressions)이 있다. 하스켈에는 do-표현식과 컴프리헨션(comprehensions)이 있으며, 이들은 함께 스칼라의 for-표현식과 유사한 기능을 제공한다.

#### 무한

#### 루프와 절반 문제
일반적인 루프 구조는 때때로 반복되는 구문이나 반복되는 조건 등 중복된 코드를 발생시킨다. 이는 다양한 이유로 발생하며, 코드 중복을 제거하거나 최소화하기 위해 제안된 다양한 솔루션이 있다. goto 구문을 사용하는 전통적인 비구조적 솔루션 외에, 일반적인 구조적 솔루션에는 루프 내부에 조건문(if 구문)을 두는 것(조건은 중복될 수 있지만 구문은 중복되지 않음)이나 반복되는 로직을 함수로 래핑하는 것(함수 호출은 중복되지만 구문은 중복되지 않음)이 포함된다.

일반적인 경우는 루프의 시작 부분은 항상 실행되지만, 마지막 반복에서는 끝 부분이 건너뛰어질 수 있는 경우다. 이는 데이크스트라에 의해 "n번과 절반" 수행되는 루프라고 불렸으며, 현재는 **루프와 절반**(loop-and-a-half) 문제라고 불린다. 일반적인 예로는 첫 번째 부분에서 데이터를 읽고, 데이터의 끝을 확인한 다음, 두 번째 부분에서 데이터를 처리하는 경우, 또는 처리하고 끝을 확인한 다음 다음 반복을 준비하는 경우가 있다. 이러한 경우 루프의 첫 번째 부분은 번 실행되지만, 두 번째 부분은 번만 실행된다.

이 문제는 적어도 1967년 커누스에 의해 인식되었으며, 비르트(Wirth)는 조기 루프 종료를 통해 이를 해결할 것을 제안했다. 1990년대 이후로 이는 다음과 같이 break 구문을 사용하는 가장 일반적으로 가르치는 솔루션이 되었다.

 'loop**
     ''statements''
     **if** ''condition'' **break**
     ''statements''
 **repeat**

이 솔루션의 미묘한 차이점은 조건이 일반적인 ''while'' 조건의 **반대**라는 것이다. 중간에 탈출구가 있는 **while** ''condition'' ... **repeat**를 다시 작성하려면 조건을 반전시켜야 한다: **loop** ... **if not** ''condition'' **exit** ... **repeat**. [[#중간 테스트 루프|중간 테스트 루프]] 제어 구조는 조건을 반전시키지 않고도 루프와 절반 사용 사례를 명시적으로 지원한다.

==== 비구조적 ====
루프 구조는 다른 반복을 발생시키거나 루프 구문 이후에 실행을 계속하게 하는 구조화된 완료 기준을 제공한다. 하지만 많은 언어에서 다양한 비구조적 제어 흐름 구조가 지원된다.

; 조기 다음 반복: 일부 언어는 다음 반복을 위해 제어를 루프 본문의 시작 부분으로 점프시키는 구조를 제공한다. 예를 들어, <code>continue</code>(가장 일반적), <code>skip</code>, <code>cycle</code>(포트란), 또는 <code>next</code>(펄 및 루비)가 있다.

; 반복 재실행: 펄이나 루비와 같은 일부 언어에는 동일한 반복에 대해 본문의 시작으로 점프하는 <code>redo</code> 구문이 있다.

; 재시작: 루비에는 첫 번째 반복부터 전체 루프를 다시 시작하는 <code>retry</code> 구문이 있다.

===== 조기 종료 =====
조기 종료는 제어를 루프 본문 이후로 점프시킨다. 예를 들어 목록을 검색할 때 항목이 발견되면 반복을 멈출 수 있다. 일부 프로그래밍 언어는 <code>break</code>(대부분의 언어), <code>Exit</code>(Visual Basic), 또는 <code>last</code>(펄)와 같은 구문을 제공한다.

다음 에이다 코드에서 루프는 X가 0일 때 종료된다.

<syntaxhighlight lang="ada">
loop
    Get(X);
    if X = 0 then
        exit;
    end if;
    DoSomething(X);
end loop;
</syntaxhighlight>

더 관용적인 스타일은 을 사용하는 것이다.

<syntaxhighlight lang="ada">
loop
    Get(X);
    exit when X = 0;
    DoSomething(X);
end loop;
</syntaxhighlight>

[[파이썬]]은 루프와 함께 else-절을 사용하여 루프가 조기에 종료되었는지(<code>break</code> 구문 사용) 여부에 따라 코드의 조건부 실행을 지원한다. 다음 파이썬 코드에서 <code>else</code> 절은 내부의 <code>if</code> 구문이 아니라 <code>for</code> 구문에 연결되어 있다. 파이썬의 <code>for</code> 및 <code>while</code> 루프는 모두 이러한 else 절을 지원하며, 이는 루프의 조기 종료가 발생하지 않은 경우에만 실행된다.

<syntaxhighlight lang="python">
for n in set_of_numbers:
    if isprime(n):
        print("Set contains a prime number")
        break
else:
    print("Set did not contain any prime numbers")
</syntaxhighlight>

====== 다단계 중단 ======
일부 언어는 중첩된 루프에서 벗어나는 것을 지원한다. 이론적으로 이를 **다단계 중단**(multi-level breaks)이라고 한다. 한 가지 일반적인 사용 예는 다차원 테이블을 검색하는 것이다. 이는 배시 및 PHP에서처럼 다단계 중단(''N''개 레벨 밖으로 탈출)을 통해 수행하거나, 에이다, Go, 자바, 러스트 및 펄에서처럼 레이블이 지정된 중단(탈출하여 주어진 레이블에서 계속)을 통해 수행될 수 있다. 다단계 중단에 대한 대안으로는 다른 레벨을 벗어나기 위해 테스트되는 상태 변수와 함께 단일 중단을 사용하거나, 벗어날 레벨에서 포착되는 예외를 사용하거나, 중첩 루프를 함수에 넣고 return을 사용하여 전체 중첩 루프의 종료를 실행하거나, 레이블과 goto 구문을 사용하는 것이 있다. C와 C++은 현재 다단계 중단이나 이름이 지정된 루프를 지원하지 않으며, 일반적인 대안은 goto를 사용하여 레이블이 지정된 중단을 구현하는 것이다. 그러나 이 기능의 포함이 제안되었으며, 자바 구문을 따라 C2Y에 추가되었다. 파이썬은 다단계 중단이나 continue를 지원하지 않는다. 이는 [https://www.python.org/dev/peps/pep-3136/ PEP 3136]에서 제안되었으나, 추가되는 복잡성이 드문 정당한 사용 사례만큼의 가치가 없다는 근거로 거부되었다.

다단계 중단 개념은 오늘날 ''코사라주 계층''(Kosaraju hierarchy)이라고 불리는 것을 발생시키기 때문에 [[이론 컴퓨터 과학]]에서 어느 정도 관심의 대상이다. 1973년 [[S. Rao Kosaraju]]는 루프에서 임의 깊이의 다단계 중단이 허용되는 한, 구조적 프로그래밍에서 추가 변수 도입을 피할 수 있음을 증명함으로써 [[구조화 정리]]를 정교화했다. 또한, 코사라주는 프로그램의 엄격한 계층 구조가 존재함을 증명했다. 모든 정수 ''n''에 대해, 추가 변수를 도입하지 않고는 깊이가 ''n'' 미만인 다단계 중단을 가진 프로그램으로 다시 작성할 수 없는 깊이 ''n''의 다단계 중단을 포함하는 프로그램이 존재한다.

데이비드 와트(David Watt)는 2004년 자신의 교과서에서 다단계 중단과 return 구문 사이의 유사성을 설명하기 위해 테넌트(Tennent)의 시퀀서(sequencer) 개념을 사용한다. 와트는 "텍스트적으로 감싸는 명령이나 프로시저의 실행을 종료하는 시퀀서"로 정의되는 ''탈출 시퀀서''(escape sequencers) 클래스가 루프에서의 중단(다단계 중단 포함)과 return 구문을 모두 포괄한다고 지적한다. 그러나 일반적으로 구현되는 것처럼 return 시퀀서는 (반환) 값을 가질 수도 있는 반면, 현대 언어에서 구현되는 중단 시퀀서는 대개 그럴 수 없다.

===== 중간 테스트 =====
다음 구조는 1972년 [[올레요한 달]]에 의해 제안되었다.

    **loop**                           **loop**
        xxx1                           read(char);
    **while** test;                    **while** **not** atEndOfFile;
        xxx2                           write(char);
    **repeat**;                        **repeat**;

여기서의 구조는 중간에 **while** 체크가 있는 **do** 루프로 생각할 수 있으며, 이는 명확한 [[#루프와 절반|루프와 절반]] 로직을 허용한다. 또한 개별 구성 요소를 생략함으로써 이 단일 구조는 대부분의 프로그래밍 언어에서 여러 구조를 대체할 수 있다. ''xxx1''이 생략되면 상단에서 테스트하는 루프(전통적인 **while** 루프)를 얻는다. ''xxx2''가 생략되면 하단에서 테스트하는 루프를 얻으며, 이는 많은 언어의 **do while** 루프와 동일하다. **while**이 생략되면 무한 루프를 얻는다. 이 구조는 또한 조기 종료와 달리 조건의 극성을 동일하게 유지할 수 있게 해주며(조기 종료는 **not**을 추가하여 극성을 반전시켜야 함), **while** 대신 **until**로 작동하게 할 수도 있다.

이 구조는 널리 지원되지 않으며, 대부분의 언어는 대신 조건부 조기 종료를 위해 **if** ... **break**를 사용한다.

이는 [[포스 (프로그래밍 언어)|포스]]와 같은 일부 언어에서 지원되며 구문은 BEGIN ... WHILE ... REPEAT이다. 또한 [[셸 스크립트]] 언어인 [[본 셸]](<code>sh</code>) 및 [[배시 (유닉스 셸)|배시]]에서도 지원되며 구문은 **while** ... **do** ... **done** 또는 **until** ... **do** ... **done**이다.

<syntaxhighlight lang="bash">
while
  statement-1
  statement-2
  ...
  condition
do
  statement-a
  statement-b
  ...
done
</syntaxhighlight>

셸 구문이 작동하는 이유는 **while**(또는 **until**) 루프가 명령 목록을 조건으로 수용하기 때문이다. 형식적으로는 다음과 같다.

  **while** ''test-commands''; **do** ''consequent-commands''; **done**

''test-commands'' 목록의 값(종료 상태)은 ''마지막'' 명령의 값이며, 이들은 줄바꿈으로 구분될 수 있어 위의 관용적 형태가 결과로 나타난다.

C와 C++에서는 쉼표 연산자를 사용하여 유사한 구조를 만들 수 있으며, [[쉼표 연산자#다른 언어|유사한 구조를 가진 다른 언어]]에서도 while 조건 안에 구문 목록을 밀어넣을 수 있다.

<syntaxhighlight lang="c">
while (statement_1, statement_2, condition) {
    statement_a;
    statement_b;
}
</syntaxhighlight>

이것이 문법적으로는 올바르지만, 권장되지는 않으며 주로 짧은 '수정 후 테스트' 사례에만 사용된다.

<syntaxhighlight lang="c">
while (read_string(s), strlen(s) > 0) {
    // ...
}
</syntaxhighlight>

==== 루프 변동량 및 불변량 ====
[[루프 변동량]]과 [[루프 불변성]]은 루프의 올바름을 표현하는 데 사용된다.

실용적인 관점에서 루프 변동량은 초기 비음수 값을 갖는 정수 표현식이다. 변동량의 값은 각 루프 반복 동안 감소해야 하지만 루프의 올바른 실행 동안 절대 음수가 되어서는 안 된다. 루프 변동량은 루프가 종료됨을 보장하는 데 사용된다.

루프 불변량은 첫 번째 루프 반복 전에 참이어야 하고 각 반복 후에도 참으로 유지되어야 하는 단언(assertion)이다. 이는 루프가 올바르게 종료될 때 종료 조건과 루프 불변량이 모두 충족됨을 의미한다. 루프 불변량은 연속적인 반복 동안 루프의 특정 속성을 모니터링하는 데 사용된다.

[[에펠 (프로그래밍 언어)|에펠]]과 같은 일부 프로그래밍 언어는 루프 변동량 및 불변량에 대한 기본 지원을 포함한다. 다른 경우에는 [[자바 (프로그래밍 언어)|자바]]의 [http://www.eecs.ucf.edu/~leavens/JML//jmlrefman/jmlrefman_12.html#SEC168 루프 구문]에 대한 [[자바 모델링 언어]](Java Modeling Language) 사양과 같이 애드온 형태로 지원된다.

==== 루프 하위 언어 ====
일부 [[리스프]] 방언은 루프를 설명하기 위한 광범위한 하위 언어를 제공한다. 초기 예제는 [[Interlisp]]의 Conversional Lisp에서 찾을 수 있다. [[커먼 리스프]]는 그러한 하위 언어를 구현하는 Loop 매크로를 제공한다.

==== 루프 시스템 상호 참조표 ====


#  <code>while (true)</code>는 전용 언어 구조가 아니므로 이 목적의 무한 루프로 간주하지 않는다.
#  C의 <code>for (''init''; ''test''; ''increment'')</code> 루프는 종종 카운팅을 위해 사용되지만, 구체적으로 카운팅 전용이 아닌 일반적인 루프 구조다.
#  심층 중단은 레이블과 goto의 사용을 통해 APL, C, C++ 및 C#에서 달성될 수 있다.
#  객체에 대한 반복은 PHP 5에서 [http://www.php.net/manual/en/language.oop5.iterations.php 추가]되었다.
#  카운팅 루프는 증가하는 목록이나 제너레이터를 반복함으로써 시뮬레이션될 수 있다(예: 파이썬의 <code>range()</code>).
#  심층 중단은 예외 처리의 사용을 통해 달성될 수 있다.
#  <code>while</code> 함수를 이 용도로 사용할 수 있으므로 특별한 구조가 없다.
#  특별한 구조는 없으나 사용자가 일반적인 루프 함수를 정의할 수 있다.
#  [[C++11]] 표준은 범위 기반 for(range-based for)를 도입했다. [[표준 템플릿 라이브러리|STL]]에는 STL [[배열|컨테이너]]를 반복하고 각 요소에 대해 [[함수 (컴퓨터 과학)|단항 함수]]를 호출할 수 있는 <code>std::for_each</code> [[추상화 (컴퓨터 과학)|템플릿]] 함수가 있다. 이 기능은 이러한 컨테이너에 대한 [[C 전처리기|매크로]]로도 구성될 수 있다.
#  숫자 루프는 정수 간격에 걸친 반복을 통해 이루어지며, 조기 종료는 종료를 위한 추가 조건을 포함함으로써 수행된다.
#  에펠은 예약어 <code>retry</code>를 지원하지만, 루프 제어가 아닌 [[예외 처리]]에서 사용된다.
#  [[자바 모델링 넝언어]](Java Modeling Language, JML) 행동 인터페이스 사양 언어가 필요하다.
#  루프 변동량이 정수여야 한다. 초한(transfinite) 변동량은 지원되지 않는다. [http://archive.eiffel.com/doc/faq/variant.html Eiffel: Why loop variants are integers]
#  D는 무한 컬렉션과 해당 컬렉션을 반복하는 기능을 지원한다. 이는 특별한 구조를 필요로 하지 않는다.
#  심층 중단은 <code>GO TO</code>와 프로시저를 사용하여 달성할 수 있다.
#  커먼 리스프는 일반 컬렉션 유형 개념보다 먼저 등장했다.
#  Odin의 일반 <code>for</code> 루프는 조건부 루프와 무한 루프를 위한 구문 단축키를 지원한다.

=== 비로컬 ===
특히 더 동적인 프로그래밍 스타일을 선호하는 많은 프로그래밍 언어는 현재 실행 지점에서 [[사전 선언된]] 지점으로 실행이 점프하게 하는 비로컬(non-local) 제어 흐름 구조를 제공한다. 주목할 만한 예는 다음과 같다.

==== 조건 처리 ====
가장 초기 [[포트란]] 컴파일러는 <code>IF ACCUMULATOR OVERFLOW</code>, <code>IF QUOTIENT OVERFLOW</code>, 및 <code>IF DIVIDE CHECK</code>를 포함하여 예외적인 조건을 처리하기 위한 구문을 지원했다. 머신 독립성을 위해 이들은 FORTRAN IV 및 Fortran 66 표준에 포함되지 않았다. 그러나 Fortran 2003 이후로 <code>IEEE_EXCEPTIONS</code> 모듈의 함수 호출을 통해 수치 문제를 테스트하는 것이 가능해졌다.

[[PL/I]]에는 발생할 수 있고 ON ''condition'' action; 에 의해 가로챌 수 있는 약 22개의 표준 조건(예: ZERODIVIDE, SUBSCRIPTRANGE, ENDFILE)이 있다. 프로그래머는 자신만의 명명된 조건을 정의하고 사용할 수도 있다.

''비구조적 if''와 마찬가지로 하나의 구문만 지정할 수 있으므로 많은 경우 제어 흐름이 재개되어야 하는 위치를 결정하기 위해 GOTO가 필요하다.

안타깝게도 일부 구현은 공간과 시간 모두에서 상당한 오버헤드(특히 SUBSCRIPTRANGE)를 가졌기 때문에 많은 프로그래머가 조건 사용을 피하려고 노력했다.

일반적인 구문 예:

 **ON** ''condition'' **GOTO** ''label''

==== 예외 처리 ====
많은 현대 언어는 기본적으로 [[예외 처리]]를 지원한다. 일반적으로 예외적인 제어 흐름은 예외 객체가 던져지는(발생하는) 것으로 시작된다. 제어는 [[콜 스택]]의 가장 안쪽 예외 핸들러로 진행된다. 핸들러가 예외를 처리하면 흐름 제어는 정상으로 돌아간다. 그렇지 않으면 핸들러 중 하나가 예외를 처리할 때까지 또는 프로그램이 가장 바깥쪽 범위에 도달하여 종료될 때까지 제어가 포함하는 핸들러로 바깥쪽으로 진행된다. 제어가 점차 바깥쪽 핸들러로 흐르면서 콜 스택을 팝하는 것과 같이 정상적으로 발생할 측면들이 자동으로 처리된다.

다음 C++ 코드는 구조적 예외 처리를 보여준다.  실행에서 예외가 전파되고 예외 객체 유형이 catch 절에 지정된 유형 중 하나와 일치하면 해당 절이 실행된다. 예를 들어,  유형의 예외가 에 의해 전파되면 제어는 2행에서 4행으로 점프하고 "Caught SomeException" 메시지가 출력된 다음 제어는  구문 이후인 8행으로 점프한다. 다른 유형의 예외가 전파되면 제어는 2행에서 6행으로 점프한다. 예외가 없으면 제어는 2행에서 8행으로 점프한다.

<syntaxhighlight lang="cpp" line>
try {
    doSomething();
} catch (const SomeException& e)
    std::println("Caught SomeException: {}", e.what());
} catch (...) {
    std::println("Unknown error");
}
doNextThing();
</syntaxhighlight>

많은 언어가 C++ 키워드(,  및 )를 사용하지만 일부 언어는 다른 키워드를 사용한다. 예를 들어 에이다는 예외 핸들러를 도입하기 위해 을 사용하고  대신 을 사용한다. [[애플스크립트]]는 다음 애플스크립트 코드에 표시된 것처럼 예외에 대한 정보를 추출하기 위해 구문에 플레이스홀더를 통합한다.

<syntaxhighlight lang = "applescript">
try
    set myNumber to myNumber / 0
on error e number n from f to t partial result pr
    if ( e = "Can't divide by zero" ) then display dialog "You must not do that"
end try
</syntaxhighlight>

많은 언어(Object Pascal, D, 자바, C#, 파이썬 포함)에서  구문의 끝에 있는  절은 의 나머지 부분에서 예외가 전파되든 아니든  구문의 끝에서 실행된다. 다음 C# 코드는 스트림 이 닫히도록 보장한다.

<syntaxhighlight lang="csharp">
FileStream stream = null;
try
{
    stream = new FileStream("logfile.txt", FileMode.Create);
    return ProcessStuff(stream);
}
finally
{
    if (stream != null)
    {
        stream.Close();
    }
}
</syntaxhighlight>

이 패턴은 일반적이기 때문에 C#은 정리를 보장하기 위해  구문을 제공한다. 다음 코드에서 ProcessStuff()가 예외를 전파하더라도 <code>stream</code> 객체는 해제된다. 파이썬의 <code>with</code> 구문과 <code>File.open</code>에 대한 루비의 블록 인수는 유사한 효과를 위해 사용된다.

<syntaxhighlight lang="csharp">
using (FileStream stream = new("logfile.txt", FileMode.Create))
{
    return ProcessStuff(stream);
}
</syntaxhighlight>

==== 컨티뉴에이션 ====


==== 제너레이터 ====


==== 코루틴 ====


==== COMEFROM ====


==== 중첩 루프에서의 이벤트 기반 조기 종료 ====
[[잔 구성체]](Zahn's construct)는 1974년에 제안되었으며, 에서 논의되었다. 수정된 버전이 여기에 제시된다.
    **exitwhen** EventA **or** EventB **or** EventC;
        xxx
    **exits**
        EventA: actionA
        EventB: actionB
        EventC: actionC
    **endexit**;

**exitwhen**은 ''xxx'' 내에서 발생할 수 있는 이벤트를 지정하는 데 사용되며, 발생은 이벤트 이름을 구문으로 사용함으로써 표시된다. 어떤 이벤트가 발생하면 관련 동작이 수행된 다음 제어가 **endexit** 바로 뒤로 전달된다. 이 구조는 어떤 상황이 적용됨을 결정하는 것과 해당 상황에 대해 취할 조치 사이에 매우 명확한 분리를 제공한다.

**exitwhen**은 개념적으로 [[예외 처리]]와 유사하며, 많은 언어에서 예외나 유사한 구조가 이 목적으로 사용된다.

다음 단순한 예제는 특정 항목을 위해 2차원 테이블을 검색하는 것을 포함한다.

    **exitwhen** found **or** missing;
        **for** I := 1 **to** N **do**
            **for** J := 1 **to** M **do**
                **if** table[I,J] = target **then** found;
        missing;
    **exits**
        found:   print ("item is in table");
        missing: print ("item is not in table");
    **endexit''';

## 같이 보기
* 연산자 (프로그래밍)

## 각주

## 외부 링크
* MDS 테크놀로지 CodeSonar, Static Analysis, Control/Data Analysis
* GrammaTech CodeSonar