Fortran 95 언어 특징

이것은 포트란 95개 언어 특징에 대한 개요다.TR-15581의 추가 기능 포함:보편적으로 구현된 향상된 데이터 유형 기능새로운 것으로 대체된 오래된 특징들은 설명되지 않는다 – 비록 대부분은 역호환성을 유지하기 위해 언어로 유지되었지만, 그러한 역사적인 특징들 중 거의 현대적인 프로그램들에서 사용되고 있지 않다.현재 표준은 Fortran 2018이다; 그것의 많은 새로운 기능들은 여전히 컴파일러에서 구현되고 있다.^[1]포트란 2003, 포트란 2008, 포트란 2018의 추가 기능은 메트칼프, 리드, 코헨이 설명한다.^[2]

언어 요소

포트란은 대소문자를 구분하지 않는다.대문자로 Fortran 키워드를 작성하고 소문자로 다른 모든 이름을 쓰는 관습은 대조적으로 입/출력 설명(외부 파일에 대한 데이터 전송 및 작동)을 제외하고 이 글에서 채택되었다.

기본 사항

포트란 언어의 기본 구성요소는 문자 집합이다.멤버들은.

• A라는 글자Z 및 ... z(문자 컨텍스트 외부와 동일)
• 숫자 0 ...9
• 밑줄 _
• 특수 인물= : + blank - * / ( ) [ ] , . $ ' ! " % & ; < > ?

컴파일러에 대한 통사적 의미를 갖는 토큰은 이러한 구성 요소로부터 만들어진다.토큰에는 다음과 같은 6가지 클래스가 있다.

토큰으로부터, 진술이 작성된다.이러한 코드는 강체 기둥 구조물에 위치할 필요가 없는 새로운 자유 소스 형태를 사용하여 코딩할 수 있다.

함수string_justat(s1, s2)                             이거 댓글이야.    유형 (끈을 매다), 의도(인) :: s1, s2    유형 (끈을 매다) string_justat    string_justat%문자열_data = s1%문자열_data(1:s1%길이) // &       s2%문자열_data(1:s2%길이)                          이건 연속이야!    string_justat%길이 = s1%길이 + s2%길이 끝 함수string_justat 

후행 주석 및 후행 연속 마크를 기록하십시오.연속선은 39개, 연속선은 132개일 수 있다.공백은 유의미하다.토큰 또는 문자 상수가 두 줄로 분할되는 경우:

               ...        의 시작&         &_이름을 붙이다                ...   '아주 긴 시간 & &string' 

주동자&또한 연속된 라인에 또한 필요하다.

기존 프로그램에 대한 소스 형태의 자동 변환은 convert.f90에 의해 수행될 수 있다.

옵션:

• 상당한 빈칸 처리.
• 들여쓰기;
• 계속을 최종 작업으로 대체;
• 하위 프로그램 END 문에 추가된 이름.
• 변환된 정수*2 등 구문.

내인성 데이터

Fortran에는 다음과 같은 5가지 내장 데이터 유형이 있다.INTEGER,REAL,COMPLEX,LOGICAL, 그리고CHARACTER각각의 종류는 종류에 의해 추가적으로 특징지어질 수 있다.기본적으로 종류에 대한 내부 표현을 정의하는데, 세 가지 숫자 유형에 대해서는 정밀도와 범위를 정의하고, 나머지 두 가지에 대해서는 스토리지 표현에 대한 세부사항을 정의한다.따라서 데이터 유형의 표현 한계를 모델링하는 추상적인 개념이다. 정수의 경우 {1, 2, 4, 8}일 수 있다(예: 정수의 경우 {1, 2, 4, 8}일 수 있음). 그러나 그러한 값은 표준에 의해 지정되지 않고 휴대할 수 없다.모든 유형에는 기본 종류가 있는데, 종류가 명시적으로 지정되지 않은 경우 사용된다.각 내적 유형에 대해, 상응하는 형태의 문자 상수가 있다.숫자 유형INTEGER, 그리고REAL서명만 할 수 있다(타입에 대한 부호 개념이 없다).COMPLEX).

리터럴 상수 및 종류

정수

기본 유형의 정수 리터럴 상수가 형식을 취함

1   0   -999   32767   +10 

종류는 명명된 상수로 정의할 수 있다.원하는 범위가 ±10일^kind 경우, 적절한 종류를 정의하기 위한 휴대용 구문,two_bytes이다

정수, 매개변수 :: 2개_2개 = 선택됨_INT_KIND(4) 

양식의 상수를 후속적으로 정의할 수 있는

-1234_2_190   +1_two_m 

여기two_byteskind type 매개 변수로서, 다음과 같은 명시적 기본 정수 리터럴 상수가 될 수도 있다.

-1234_2 

그러나 그러한 용도는 휴대할 수 없다.

KIND 함수는 다음과 같은 종류 매개변수의 값을 제공한다.

친절한(1)            친절한(1_two_m) 

그리고RANGE함수는 실제 소수점 범위를 제공하므로 사용자가 바이트에 실제 매핑해야 함:

범위(1_two_m) 

또한 (초기화) 문에서는 이진수(B), 8진수(O) 및 16진수(Z) 상수를 사용할 수 있다(흔히 비공식적으로 "BOZ 상수"라고 함).

B'01010101'   O'01234567'   Z'10fa' 

진짜

최소 두 종류의 실제 종류가 있다. 기본값은 기본이고 정밀도는 더 높은 유형이다(이것이 대체됨).DOUBLE PRECISION).SELECTED_REAL_KIND함수는 원하는 범위와 정밀도에 대한 종류 번호를 반환한다. 최소 9자리의 정밀도와 10~10⁻⁹⁹⁹⁹ 범위의 경우 다음과 같이 지정할 수 있다.

정수, 매개변수 :: 장기의 = 선택됨_REAL_KIND(9, 99) 

및 리터럴은 후속적으로 다음과 같이 지정된다.

1.7_길이 

또한 본질적인 기능도 있다.

친절한(1.7_길이)   정밀도(1.7_길이)   범위(1.7_길이) 

즉, 유형 값, 실제 정밀도(여기서 최소 9), 실제 범위(여기서 최소 99).

복합체

COMPLEX데이터 유형은 두 개의 정수 또는 실제 구성 요소로 구성된다.

(1, 3.7_길이) 

논리적인

논리 상수의 기본값은 다음 두 가지뿐입니다..TRUE., 그리고.FALSE.여기, 다른 종류도 있을 수 있다.논리에는 고유의 종류 조회 기능이 없지만, 에 대해 지정된 종류를 사용한다.INTEGERs; 의 기본 유형LOGICALNUTER와 동일하다.

.거짓의.   .진실의._원_바이트 

그리고KIND기능이 예상대로 작동함:

친절한(.진실의.) 

캐릭터

다음에 대한 리터럴 상수의 형식CHARACTER데이터 유형:

'끈'   "또"   '견적'   ''''''' 

(마지막은 빈 문자열)다른 종류(예를 들어 ASCII 문자열과 UNICODE 문자열을 구별하기 위해)가 허용되지만 컴파일러에 의해 광범위하게 지원되지는 않는다.다시 말하지만, 친절한 값은 에 의해 주어진다.KIND함수:

친절한('ASCII') 

수 모델 및 내재가함수

숫자 유형은 관련된 조회 함수를 가진 숫자 모델에 기초한다(이들의 값은 그들의 인수의 값과 무관하며, 인수는 오직 종류를 제공하기 위해서만 사용된다).이러한 기능은 휴대용 숫자 소프트웨어에 중요하다.

스칼라 변수

5가지 내인성 유형에 해당하는 스칼라 변수는 다음과 같이 지정된다.

정수(친절한=2) :: i 진짜(친절한=장기의) :: a 복합체         :: 현재의 논리적인         :: 프라브다 캐릭터(렌=20) :: 단어 캐릭터(렌=2, 친절한=간지) :: 칸지_워드 

선택 사항인 경우KIND매개 변수는 기본값이 아닌 종류를 지정하며::표기법은 유형과 속성을 변수 이름과 선택적 초기 값에서 구분하여 전체 변수 규격과 초기화를 하나의 문장에 입력할 수 있도록 한다(이전 표준에서는 속성 및 이니셜라이저를 여러 문장으로 선언해야 했다.위의 예에서는 필요 없지만(추가적인 속성과 초기화가 없기 때문에), 대부분의 Fortran-90 프로그래머들은 어디에서나 그것을 사용하는 습관을 얻는다.

LEN=특정인은 에만 해당된다.CHARACTERs 및 문자열 길이 지정(이전된 문자열 포함)*len형식. 명시적.KIND=, 그리고LEN=지정자는 선택 사항:

캐릭터(2, 간지) :: 칸지_워드 

역시 효과가 있다.

다른 몇 가지 흥미로운 특징들이 있다.에서와 같은 변위 문자열처럼

캐릭터(80) :: 선을 긋다    ... = 선을 긋다(i:i)                     ! 하위 문자열 

예전에는 가능했었고, 지금은 부전선이

'0123456789'(i:i) 

또한 제로 길이 문자열도 허용된다.

선을 긋다(i:i-1)       ! 0-길이 문자열 

마지막으로, 일련의 내재적 문자함수가 있는데, 예는 다음과 같다.

파생 데이터 유형

파생 데이터 유형의 경우 먼저 형식의 형식을 정의해야 한다.

유형사람    캐릭터(10) 이름을 붙이다    진짜나이를 먹다 끝 유형사람 

그런 다음 해당 유형의 변수를 정의할 수 있다.

유형(사람) 너, 나 

파생된 유형의 구성 요소를 선택하려면%한정자가 사용됨:

너%나이를 먹다 

파생 유형의 리터럴 상수는 다음과 같은 형식을 갖는다.

너 = 사람('스미스', 23.5) 

구조 시공자로 알려져 있다.정의는 이전에 정의된 형식을 가리킬 수 있다.

유형점을 찍다    진짜x, y 끝 유형점을 찍다 유형삼각형의    유형(점을 찍다) a, b, c 끝 유형삼각형의 

및 다음과 같이 삼각형 유형의 변수에 대해

유형(삼각형의) t 

활자의 각 구성 요소point로 액세스됨

t%a   t%b   t%c 

즉, 유형 실제의 궁극적인 구성요소를 갖는다.

t%a%x   t%a%y   t%b%x   등. 

(참고:%점보다는 한정자가 선택되었다(.) 연산자 표기법에 대한 잠재적 모호성 때문에, 다음과 같다..OR.).

암시적 및 명시적 타이핑

달리 지정하지 않는 한 문자 I, J, K, L, M, N으로 시작하는 모든 변수는 기본값이다.INTEGERs, 그리고 다른 모든 것은 디폴트REAL; 다른 데이터 형식은 명시적으로 선언되어야 한다.이것은 묵시적 타이핑이라고 알려져 있으며 FORTRAN 초기의 유산이다.이러한 기본값은 다음과 같은 문장으로 재정의할 수 있다.

암시적복합체(Z) 암시적캐릭터(A-B) 암시적진짜(C-H,N-Y) 

그러나 모든 변수를 명시적으로 입력하는 것이 좋은 관행이며, 이는 문구를 삽입하여 강제할 수 있다.IMPLICIT NONE각 프로그램 유닛의 시작 부분에.

배열

배열은 그 자체로 변수로 간주된다.모든 배열은 그 유형, 순위, 모양(각 차원의 범위를 정의함)으로 특징지어진다.각 차원의 한계는 기본적으로 1과 크기지만 임의의 한계는 명시적으로 지정할 수 있다. DIMENSION키워드는 선택 사항이며 속성으로 간주된다. 생략할 경우 배열 형식 이름 뒤에 배열 모양을 지정해야 한다.예를 들어,

진짜:: a(10) 정수, 치수(0:100, -50:50) :: 지도를 그리다 

1등급과 2등급의 두 배열을 선언하며, 이 배열을 열 주 순서로 배열한다.원소는, 예를 들면,

a(1)  a(i*j) 

그리고 스칼라.첨자는 스칼라 정수 식일 수 있다.

섹션은 배열 변수의 일부로서 배열 자체:

a(i:j)               1위! 지도를 그리다(i:j, k:l:m)      2위! a(지도를 그리다(i, k:l))       ! 벡터 첨자 a(3:2)               ! 제로 길이 

전체 배열과 배열 섹션은 배열 값 객체다.배열 값 상수(구성자)를 사용할 수 있으며, 다음 항목으로 묶음(/ ... /):

(/ 1, 2, 3, 4 /) (/ ( (/ 1, 2, 3 /), i = 1, 4) /) (/ (i, i = 1, 9, 2) /) (/ (0, i = 1, 100) /) (/ (0.1*i, i = 1, 10) /) 

암시적-DO 루프 표기법 사용Fortran 2003은 브래킷의 사용을 허용한다. [1, 2, 3, 4], 그리고[([1,2,3], i=1,4)]위의 처음 두 예시 대신에, 많은 컴파일러들이 지금 이것을 지지한다.물론 파생된 데이터 유형은 다음과 같은 배열 구성요소를 포함할 수 있다.

유형삼중의    진짜, 치수(3) :: 꼭지점 끝 유형삼중의 유형(삼중의), 치수(4) :: t 

하도록

• t(2)스칼라(구조물)
• t(2)%vertex스칼라의 배열 구성요소

데이터 초기화

변수에는 규격 문에 지정된 초기 값을 지정할 수 있다.

진짜, 치수(3) :: a = (/ 0.1, 0.2, 0.3 /) 

기본 초기 값은 파생 데이터 유형의 구성요소에 제공될 수 있다.

유형삼중의    진짜, 치수(3) :: 꼭지점 = 0.0 끝 유형삼중의 

로컬 변수가 절차 내에서 초기화되면 해당 변수는 암시적으로 SAVE 속성을 획득한다.

진짜, 치수(3) :: 점을 찍다 = (/ 0.0, 1.0, -1.0 /) 

이 선언은 다음과 같다.

진짜, 치수(3), SAVE :: 점을 찍다 = (/ 0.0, 1.0, -1.0 /) 

서브루틴 또는 함수 내의 로컬 변수의 경우SAVE 속성은 프로시저 호출 후 로컬 변수가 값을 유지한 다음 프로시저로 복귀할 때 저장된 값으로 변수를 초기화하도록 한다.

매개변수 속성

명명된 상수는 다음을 추가하여 직접 지정할 수 있다.PARAMETER유형 문에 대한 특성 및 상수 값:

진짜, 치수(3), 매개변수 :: 밭을 갈다 = (/ 0., 1., 2. /) 유형(삼중의), 매개변수 :: t = 삼중의( (/ 0., 0., 0. /) ) 

DATA 문

그DATA문장은 스칼라와 또한 파생형식의 배열과 변수에 사용될 수 있다.또한 2진수, 8진수 또는 16진수 값으로 초기화할 수 있는 유일한 방법이다.

유형(삼중의) :: t1, t2 데이터t1/삼중의( (/ 0., 1., 2. /) )/, t2%꼭지점(1)/123./ 데이터 배열(1:64) / 64*0/ 데이터i, j, k/ B'01010101', O'77', Z'off'/ 

초기화 식

에 사용된 값DATA, 그리고PARAMETER문 또는 이러한 속성과 함께 배열 및 구조 생성자에 대한 참조, 정수 또는 문자 인수와 결과를 포함하는 요소 내적 함수, 6개의 변환 함수를 포함할 수 있는 상수 표현식이다.REPEAT, SELECTED_INT_KIND, TRIM, SELECTED_REAL_KIND, RESHAPE, 그리고TRANSFER(내재 절차 참조):

정수, 매개변수 :: 장기의 = 선택됨_REAL_KIND(12),   &                       배열하다(3) = (/ 1, 2, 3 /) 

사양식

조회 함수 참조를 포함할 수 있는 일정하지 않은 스칼라 정수 식을 사용하여 변수의 세부 정보를 지정할 수 있다.

서브루틴s(b, m, c)    사용하다모드의                                 !에는 a이 포함되어 있다.    진짜, 치수(:, :)             :: b    진짜, 치수(UBUND(b, 1) + 5) :: x    정수                           :: m    캐릭터(렌=*)                  :: c    캐릭터(렌= m + 렌(c))        :: 참조하다    진짜 (선택됨_REAL_KIND(2*정밀도(a))) :: z 

표현식 및 할당

스칼라 숫자

일반적인 산술 연산자를 사용할 수 있음 –+, -, *, /, **(여기서 우선순위가 증가하는 경우).

괄호는 필요한 경우 평가 순서를 나타내기 위해 사용된다.

a*b + c     ! * 먼저 a*(b + c)   ! + 첫번째 

스칼라 숫자 식 및 할당 규칙은 기본값이 아닌 종류를 수용한다.따라서 혼합 모드 숫자 표현식과 할당 규칙은 다음과 같은 예상 방식으로 서로 다른 종류 유형 매개변수를 통합한다.

리얼2 = 정수0 + real1 

개종하다integer0와 같은 종류의 진짜 가치로real1; 결과는 동종이며, 동종류로 전환된다.real2임무를 띠고

이러한 기능은 실수의 정수에 대한 반올림을 제어하는 데 사용할 수 있다.

• NINT: 가장 가까운 정수에 반올림, 정수 결과 반환
• ANINT: 가장 가까운 정수에 반올림, 실제 결과 반환
• INT: 잘라내기(0을 향해 회전), 반환 정수 결과
• AINT: 잘라내기(원형 0), 실제 결과 반환
• CEILING: 인수 이상의 최소 적분 값(반올림)(Fortran-90)
• FLOOR: 인수보다 크지 않은 최대 적분 값(반올림)(Fortran-90)

스칼라 관계 운영

숫자 유형의 스칼라 관계 연산에는 다음과 같은 일련의 내장 연산자가 있다.

<    <=    ==   /=   >   >= ..LE. .EQ.NE.GT.GE.

(위의 양식은 Fortran-90에 새로이 적용되었으며, 그 아래에 오래된 동등한 양식이 제시되어 있다.)예제 식:

a < b .AND. i /= j      ! 숫자 변수의 경우 깃발을 꽂다 = a == b           ! 논리 변수 플래그의 경우 

스칼라 문자

스칼라 문자와 주어진 경우CHARACTER(8) result

쓰는 것은 합법이다.

결과(3:5) = 결과(1:3)    ! 중복 허용됨 결과(3:3) = 결과(3:2)    ! null 문자열 할당 없음 

연결은 운영자 '/'가 수행한다.

결과 = 'abcde'//'123' 파일 이름 = 결과//'.dat' 

파생 데이터 유형

상호 또는 내재가 있는 파생 데이터 유형 사이에 내장된 작업(구성요소별로 정의된 할당 제외)이 존재하지 않는다.기존 또는 사용자 지정 연산자의 의미는 다음과 같이 정의될 수 있다.

유형스트링80    정수길이    캐릭터(80) 가치를 매기다 끝 유형스트링80 캐릭터::    char1, char2, char3 유형(스트링80):: str1,  str2,  str3 

우리는 쓸 수 있다.

str3  = str1//str2       ! 작업을 정의해야 함 str3  = str1.콘카트.str2 ! 작업을 정의해야 함 char3 = char2//char3     ! 내재 연산자만 해당 str3  = char1            ! 할당을 정의해야 함 

고유 기호의 "과부하" 사용에 주목하십시오.//그리고 명명된 연산자,.concat.. 두 경우 간의 차이점은 내재가동자 토큰의 경우 통상적인 우선 순위 규칙이 적용되는 반면, 명명된 운영자의 우선 순위는 단일 운영자로 가장 높거나 이진수로 가장 낮다는 것이다.인

벡터3 = 매트릭스    *    벡터1  + 벡터2 벡터3 =(매트릭스 .시대. 벡터1) + 벡터2 

두 식은 그림과 같이 적절한 괄호를 추가하는 경우에만 동등하다.각 경우에, 모듈에는 다음과 같이 운영자와 할당을 정의하는 절차와 해당 운영자-절차 연관성이 정의되어야 한다.

인터페이스연산자(//) ! // 연산자를 호출 문자열_concat 절차로 오버로드   모듈 절차string_justat 엔드 인터페이스 

문자열 연결 함수는 Basics에 이미 나와 있는 것보다 더 정교한 버전이다.두 문자열이 함께 사전 설정된 80자 제한을 초과할 때 발생하는 오류 조건을 처리하려면 서브루틴을 사용하여 연결 작업을 수행하는 것이 안전하다는 점에 유의하십시오(이 경우 작업자 오버로드는 적용되지 않을 것이다).

모듈string_type    INMITIAL NONE 유형스트링80       정수길이       캐릭터(렌=80)   :: 문자열_data    끝 유형스트링80    인터페이스할당(=)       모듈 절차c_to_s_message, s_to_c_properties    엔드 인터페이스 인터페이스연산자(//)       모듈 절차string_justat    엔드 인터페이스 포함하다 서브루틴c_to_s_message(s, c)       유형 (스트링80), 의도(아웃)    :: s       캐릭터(렌=*), 의도(인)  :: c       s%문자열_data = c       s%길이 = 렌(c)    서브루틴 끝c_to_s_message    서브루틴s_to_c_properties(c, s)       유형 (스트링80), 의도(인)     :: s       캐릭터(렌=*), 의도(아웃) :: c       c = s%문자열_data(1:s%길이)    서브루틴 끝s_to_c_properties    유형(스트링80) 함수string_justat(s1, s2)       유형(스트링80), 의도(인) :: s1, s2       유형(스트링80) :: s       정수 :: n1, n2       캐릭터(160) :: 단조로운       n1 = LEN_TRIM(s1%문자열_data)       n2 = LEN_TRIM(s2%문자열_data)       IF (n1+n2 <= 80) 그때          s%문자열_data = s1%문자열_data(1:n1)//s2%문자열_data(1:n2)       기타  ! 이것은 처리되어야 할 오류 조건이다 - 지금은 단지 잘라내기만 하면 된다.          단조로운 = s1%문자열_data(1:n1)//s2%문자열_data(1:n2)          s%문자열_data = 단조로운(1:80)       엔디프       s%길이 = LEN_TRIM(s%문자열_data)       string_justat = s    끝 함수string_justat 엔드 모듈string_type  프로그램본래의    사용하다string_type    유형(스트링80) :: s1, s2, s3    호출c_to_s_message(s1,'내 이름은')    호출c_to_s_message(s2,'리너스 토발즈')    s3 = s1//s2    쓰기(*,*) '결과: ',s3%문자열_data    쓰기(*,*) '길이: ',s3%길이 종료 프로그램 

구조 생성자에서도 허용되는 표현식에 대해 다음과 같은 정의된 연산자가 필요하다(유형 데이터 유형 참조).

str1 = 끈을 매다(2, char1//char2)  ! 구조 생성자 

배열

그 다음에 배열의 경우, 동일한 형태(적합성)인 한, 운영과 할당은 요소별로 명확한 방법으로 확장된다.예를 들어, 다음과 같은 선언이 있다.

진짜, 치수(10, 20) :: a, b, c 진짜, 치수(5)      :: v, w 논리적인깃발을 꽂다(10, 20) 

다음과 같이 기록될 수 있다.

a = b                                       ! 전체 배열 할당 c = a/b                                     ! 전체 배열 분할 및 할당 c = 0.                                      ! 스칼라 값의 전체 배열 할당 w = v + 1.                                  ! 스칼라 값에 전체 배열 추가 w = 5/v + a(1:5, 5)                         ! 어레이 분할 및 섹션에 추가 깃발을 꽂다 = a==b                                 ! 전체 어레이 관계 테스트 및 할당 c(1:8, 5:10) = a(2:9, 5:10) + b(1:8, 15:20) ! 어레이 섹션 추가 및 할당 v(2:5) = v(1:4)                             ! 중복 섹션 할당 

병렬 및 벡터 기계에서 최적화를 허용하기 위해 표현 평가 순서를 지정하지 않는다.물론 파생형 배열의 연산자를 정의해야 한다.

숫자 계산에 유용한 실제 내적함수는 다음과 같다.

천장 바닥 모듈로 (또한 정수의) 지수분수 가장 가까운 RR공간 간격 스케일 SET_EXPONENT 

이러한 배열은 모든 FORTRAN 77 함수(LEN 제외)와 마찬가지로 배열 인수(기본)에 대해 평가된 배열이다.

INT진짜CMPLX 아인트 아닌트 네인트 ABS MOD 기호 DIM MAX MIN  SQRT EXP 로그 LOG10           신코스 탄아신아코스 아탄아탄2 신호코시탄  아이맥 콘지  엘지 엘지 엘레 LLT ICHAR 색인 

(마지막 7개는 등장인물을 위한 것이다.)

제어문

분기 및 조건

심플GO TO 라벨은 존재하지만 일반적으로 피한다 – 대부분의 경우 보다 구체적인 분기 구조는 보다 명확하고 동일한 논리를 달성할 것이다.

간단한 조건부 테스트는IF문:IF (a > b) x = y

만발한 사람IF구성 요소는 에 의해 설명된다.

IF (i < 0) 그럼 IF (j < 0) 그럼       x = 0.    기타       z = 0.    엔디프 기타 IF (k < 0) 그럼    z = 1. 기타    x = 1. 엔디프 

CASE 구성

그CASE구성(construct)은 계산된 것을 대체하는 것이다.GOTO는 더 나은 구조로 되어있으며 문 라벨의 사용을 요구하지 않는다.

케이스 선택 (번호를 붙이다)       ! 정수 유형 수 케이스 (:-1)                 ! 모든 값이 0보다 작음    n_사인 = -1 케이스 (0)                   ! 단 0!    n_사인 = 0 케이스 (1:)                  ! 모든 값이 0을 초과함    n_사인 = 1 선택 종료 

각각의CASE선택자 목록에는 다음과 같은 정수, 문자 또는 논리적 상수의 목록 및/또는 범위가 포함될 수 있으며, 이러한 값은 선택자 내부 또는 사이에 겹치지 않을 수 있다.

케이스 (1, 2, 7, 10:17, 23) 

기본값 사용 가능:

케이스체납 

평가는 한 개, 성냥은 한 개뿐이다.

DO construct

단순화되었지만 충분한 형태의 ...DO구성 요소는 에 의해 설명된다.

바깥의: DO 내면의:    DOi = j, k, l      ! l의 스텝에서 j에서 k까지 (l은 선택사항)              :              IF (...) 사이클              :              IF (...) 종료바깥의              :           종료 작업내면의        종료 작업바깥의 

여기서 루프 이름을 선택적으로 지정하여 EX를IT 또는 CYCLE 문에서는 어떤 루프를 의미하는지 명시할 수 있다.

전부는 아니지만 많은 간단한 루프들은 배열 표현식과 할당으로 대체되거나 새로운 내적 함수로 대체될 수 있다.예를 들어.

합계를 내다 = 0. DOi = m, n    합계를 내다 = 합계를 내다 + a(i) 종료 작업 

단순해지다tot = SUM( a(m:n) )

프로그램 단위 및 절차

정의들

이 주제를 논의하기 위해서는 몇 가지 정의가 필요하다.논리적으로 실행 가능한 프로그램은 하나의 기본 프로그램과 0개 이상의 하위 프로그램(또는 절차)으로 구성된다. 이러한 프로그램들은 뭔가를 한다.하위 프로그램은 기능 또는 서브루틴으로, 외부, 내부 또는 모듈 서브루틴이다. (외부 서브루틴은 우리가 FORTRAN 77로부터 알고 있던 것이다.)

그러나 조직적인 관점에서 보면 완전한 프로그램은 프로그램 단위로 구성된다.이들은 메인 프로그램, 외부 하위 프로그램 또는 모듈 중 하나이며 별도로 컴파일할 수 있다.

주(및 전체) 프로그램의 예는 다음과 같다.

프로그램시험하다    프린트 *, '헬로 월드!' 종료 프로그램시험하다 

실행 가능한 프로그램을 구성하는 메인 프로그램과 외부 하위 프로그램의 예는 다음과 같다.

프로그램시험하다    호출print_message 종료 프로그램시험하다 서브루틴print_message    프린트 *, '헬로 월드!' 서브루틴 끝print_message 

함수의 형태는

함수이름을 붙이다(arg1, arg2) ! 0개 이상의 인수    :                         이름을 붙이다 = ...    : 끝 함수이름을 붙이다 

함수의 기준 형식은x = name(a, b)

내부 절차

내부 하위 프로그램은 다른 하위 프로그램(최대 한 단계의 중첩)에 포함된 프로그램이며 문 기능을 대체한다.

서브루틴바깥의    진짜x, y    : 포함하다 서브루틴내면의       진짜y       y = x + 1.       :    서브루틴 끝내면의     ! SUBROUTINE 필수 사항 서브루틴 끝바깥의 

라고 말한다.outer의 주최자다inner, 그리고 저것inner다음 엔티티에 대한 액세스 권한 획득outer호스트 연합에 의해(예: ~로)x), 반면y에 대한 지역 변수inner.

명명된 엔티티의 범위는 여기서 범위 지정 단위임outer덜하다inner, 그리고inner.

프로그램 단위 및 외부 절차의 명칭은 글로벌하며, 묵시-DO 변수의 명칭은 이를 포함하는 문장의 범위를 가진다.

모듈

모듈이 패키징에 사용됨

• 글로벌 데이터(Fortran 77의 공통 데이터 및 블록 데이터 대체);
• 유형 정의(범위 지정 단위)
• 하위 프로그램(그 중에서도 Fortran 77의 ENTERNT 사용을 대체하는 프로그램)
• 인터페이스 블록(다른 범위 지정 장치, 인터페이스 블록 참조);
• 명성주의 단체들 (모든 교과서 참조).

형식 정의, 인터페이스 블록 및 기능 하위 프로그램을 포함하는 모듈의 예는 다음과 같다.

모듈interval_properties    유형간격을 두고       진짜더 낮게, 상부의    끝 유형간격을 두고    인터페이스연산자(+)        모듈 절차add_message    엔드 인터페이스    : 포함하다 함수add_message(a,b)       유형(간격을 두고), 의도(인) :: a, b       유형(간격을 두고) add_message       add_message%더 낮게 = a%더 낮게 + b%더 낮게       add_message%상부의 = a%상부의 + b%상부의    끝 함수add_message             ! Function    : 엔드 모듈interval_properties 

그리고 간단한 진술

      사용하다interval_properties 

모듈의 모든 엔티티에 사용 연관성을 제공한다.모듈 하위 프로그램은 내부 하위 프로그램을 포함할 수 있다.

접근성 제어

그PUBLIC, 그리고PRIVATE속성은 실체의 범위를 제한하기 위해 모듈의 규격에 사용된다.속성 양식은

진짜, 공용     :: x, y, z           ! 기본값 정수, 사설 :: u, v, w 

그리고 진술서 양식은

공용  :: x, y, z, 연산자(.덧셈을.) 사설 :: u, v, w, 할당(=), 연산자(*) 

문양식은 운영자에 대한 접근을 제한하는 데 사용되어야 하며, 또한 전체 디폴트 변경에도 사용할 수 있다.

사설                        ! 모듈의 기본 설정 공용  :: 오직_이것만 

파생형 타입의 경우, 타입과 그 구성요소는 모두 PLOCAL이며, 타입은 PLOCAL이며 그 구성요소는 PRIVEL이다(타입은 단지 볼 수 있고 하나는 그 세부사항을 쉽게 변경할 수 있다), 또는 그 모든 것이 PRIVEL이다(모듈 내부용만 사용).

모듈내 것    사설 유형, 공용 :: 리스트를 작성하다       진짜x, y       유형(리스트를 작성하다), 포인터 :: 다음에    끝 유형리스트를 작성하다    유형(리스트를 작성하다) :: 나무    : 엔드 모듈내 것 

그USE재무제표의 목적은 모듈에 있는 엔티티에 대한 접근권을 얻는 것이다.가져온 이름이 로컬 이름과 동일한 경우 이름 충돌을 해결하는 옵션이 있다.

사용하다내 것, local_list => 리스트를 작성하다 

또는 사용된 도면요소를 지정된 집합으로 제한하려면:

사용하다내 것, 오직 : 리스트를 작성하다 

이 두 가지를 결합할 수 있다.

사용하다내 것, 오직 : local_list => 리스트를 작성하다 

논쟁들

우리는 더미 인수의 의도를 다음과 같이 명시할 수 있다.

서브루틴섞다 (앵무새들, 카드들)   정수, 의도(인)  :: 앵무새들   정수, 의도(아웃), 치수(앵무새들) :: 카드들 

또한 INOUT가 가능하다. 여기서 실제 인수는 변수여야 한다(상수일 수 있는 기본 경우와 달리).

인수는 선택 사항일 수 있다.

서브루틴민콘(n, f, x, 상부의, 더 낮게, 평등., 불평등, 볼록하게 하다, xstart)    진짜, 선택적, 치수 :: 상부의, 더 낮게    :    IF (현재(더 낮게)) 그럼   ! 실제 인수의 존재 여부 테스트    : 

우리가 전화할 수 있도록 허락하다.mincon에 의해

호출민콘 (n, f, x, 상부의) 

논쟁은 (먼저 오는) 위치보다는 키워드가 될 수 있다.

호출민콘(n, f, x, 평등.=0, xstart=x0) 

선택적 및 키워드 인수는 내부 또는 모듈 절차 또는 인터페이스 블록과 함께 명시적 인터페이스로 처리된다.

인터페이스 블록

내부 또는 모듈 하위 프로그램에 대한 참조는 '설명'된 인터페이스를 통해 이루어진다(즉, 컴파일러는 모든 세부 정보를 볼 수 있다).외부(또는 더미) 절차에 대한 참조는 대개 '불확실하다'( 컴파일러가 세부사항을 가정함)이다.그러나 이 경우에도 명시적인 인터페이스를 제공할 수 있다.모듈 내에 배치하거나 직접 삽입한 해당 절차의 헤더, 사양 및 END 문장의 사본이다.

진짜함수최소의(a, b, 펑크)   ! func(x) 함수의 최소값을 반환함   ! 간격 (a,b)   진짜, 의도(에) :: a, b   인터페이스     진짜함수펑크(x)       진짜, 의도(인) :: x     끝 함수펑크   엔드 인터페이스   진짜f,x   :   f = 펑크(x)   ! 사용자 기능의 호출.   : 끝 함수최소의 

명시적 인터페이스는 필수 사항.

• 선택적 및 키워드 인수.
• POINTOR 및 TARGET 인수( 포인터 참조);
• POINTOR 함수 결과;
• 새로운 스타일의 배열 인수 및 배열 함수(어레이 처리).

그것은 실제 인수와 더미 인수 사이의 컴파일 시간에 완전한 확인을 허용한다.

일반적으로 절차 인터페이스가 명시적임을 확인하는 최선의 방법은 관련 절차를 모듈에 배치하거나 내부 절차로 사용하는 것이다.

오버로드 및 일반 인터페이스

인터페이스 블록은 특정 절차에 대한 일반적 이름을 정의할 수 있는 메커니즘을 제공한다.

인터페이스감마시키다                   ! 일반 이름    함수감마(X)              ! 구체적인 이름       진짜 (선택됨_REAL_KIND( 6)) 감마, x    끝 함수감마(X)              ! 구체적인 이름       진짜 (선택됨_REAL_KIND(12)) 감마, x    끝 엔드 인터페이스 

여기서 일반 이름에 해당하는 특정 이름 집합은 모두 함수 또는 모든 서브루틴이어야 한다.만약 이 인터페이스가 모듈 내에 있다면, 그것은 단순하다.

인터페이스감마시키다    모듈 절차감마, 감마 엔드 인터페이스 

기존 이름(예: SIN)을 사용할 수 있고 컴파일러는 올바른 연관성을 분류한다.

우리는 이미 정의된 운영자와 할당을 위한 인터페이스 블록의 사용을 보았다(모듈 참조).

재귀

간접 재귀는 다차원 통합에 유용하다.을 위해

부피 = 통합하다(FY, 이바운즈) 

우리가 했을지도 모른다.

재귀 함수통합하다(f, 한도를 정하다)    ! f(x)를 경계(1)에서 경계(2)로 적분    진짜통합하다    인터페이스 함수f(x)          진짜f, x       끝 함수f    엔드 인터페이스    진짜, 치수(2), 의도(인) :: 한도를 정하다    : 끝 함수통합하다 

직사각형 위에 f(x, y)를 통합하려면:

함수FY(y)    사용하다펑크           ! 모듈 func는 f기능을 포함한다.    진짜FY, y    이발 = y    FY = 통합하다(f, xbounds) 끝 

직접 재귀(direct recurrency)는 다음과 같이 절차 자체를 호출하는 경우를 말한다.

재귀 함수요인의(n) 결과(재방송하다)    정수재방송하다, n    IF(n.EQ.0) 그럼       재방송하다 = 1    기타       재방송하다 = n*요인의(n-1)    엔디프 끝 

여기, 우리는 주목한다.RESULT조항 및 종료 시험.

순수 절차

이것은 병렬 컴퓨팅을 위한 기능이다.

FORALL 문과 구성에서, 함수의 모든 부작용은 병렬 프로세서의 최적화를 방해할 수 있다 – 할당 실행 순서는 결과에 영향을 미칠 수 있다.이 상황을 통제하기 위해, 우리는PURE에 대한 키워드.SUBROUTINE또는 FUNCTION진술 – 절차(단순히 설명)가 다음과 같은 주장:

• 글로벌 변수를 변경하지 않고,
• I/O 수행 없음,
• 저장된 변수가 없음(과(와)SAVE호출 간 값을 유지하는 속성) 및
• 함수의 경우, 해당 주장을 변경하지 않는다.

컴파일러는 다음과 같이 이것이 사실인지 확인할 수 있다.

순수함수계산하다 (x) 

모든 본질적인 함수는 순수하다.

배열 처리

Fortran에는 다음과 같은 두 가지 주요 이유로 어레이 처리가 포함된다.

• 코드의 기초적인 수학적 형태에 가까워지는 공칭적 편의성
• 컴파일러에게 추가적인 최적화 기회를 제공한다(최적화를 저하시킬 수 있는 기회는 많지만!).

동시에, 이 영역의 기능성에 대한 주요 확장도 추가되었다.우리는 이미 #Array 1과 여기 #Array 2 위의 전체 배열을 만나 이제 주제를 개발한다.

제로 크기 어레이

제로 사이즈의 배열은 프로그래머가 특별한 코딩 없이 포르트란이 합법적인 대상으로 취급한다.그러므로, in.

DOi = 1,n    x(i) = b(i) / a(i, i)    b(i+1:n) = b(i+1:n) - a(i+1:n, i) * x(i) 종료 작업 

다음과 같은 경우 최종 반복에 특별한 코드가 필요하지 않다.i = n. 0 크기의 배열은 정의되는 것으로 간주되지만, 형상 모수(0,2)는 형상 모수(0,3)와 일치할 수 없는 반면,x(1:0) = 3유효한 '아무 것도 하지 말라'는 진술이다.

가정된 형태 배열

이는 가정된 크기의 배열을 위한 확장 및 교체다.다음과 같은 실제 인수가 주어짐:

진짜, 치수(0:10, 0:20) :: a    : 호출후보선수(a) 

해당 더미 인수 규격은 배열의 형식과 순위만 정의하고 그 형태는 정의하지 않는다.이 정보는 명시적 인터페이스로, 종종 인터페이스 블록을 사용하여 이용할 수 있어야 한다(인터페이스 블록 참조).그래서 우리는 단지 글을 쓴다.

서브루틴후보선수(da)    진짜, 치수(:, :) :: da 

그리고 이것은 마치da치수화되었다(11,21)그러나 그에 따라 하한 및 배열 맵을 지정할 수 있다.

진짜, 치수(0:, 0:) :: da 

기본 하한은 1이고 기본 상한이 해당 범위인 경우 경계가 아닌 형상이 통과된다.

자동 배열

다음 용도에 대한 부분적 대체EQUIVALENCE이 설비에 의해 제공되었으며, 에서와 같이 로컬, 임시 어레이에 유용하다.

서브루틴바꾸다(a, b)    진짜, 치수(:)       :: a, b    진짜, 치수(사이즈(a)) :: 일을 하다    일을 하다 = a    a = b    b = 일을 하다 서브루틴 끝바꾸다 

실제 스토리지는 일반적으로 스택에서 유지된다.

할당 가능 및 할당

Fortran은 스토리지를 동적으로 할당하고, 힙 스토리지 메커니즘에 의존하며(또 다른 용도 대체)EQUIVALENCE전체 프로그램에 대한 작업 배열을 설정하는 예는 다음과 같다.

모듈work_array    정수n    진짜, 치수(:,:,:), allocationatabLE :: 일을 하다 엔드 모듈 프로그램본래의    사용하다work_array    읽다 (입력하다, *) n    할당하다(일을 하다(n, 2*n, 3*n), 통계분석=지위)    :    할당 해제 (일을 하다) 

워크 배열은 a를 통해 전체 프로그램을 통해 전파될 수 있다.USE각 프로그램 유닛의 문장.우리는 명시적인 하한을 명시하고 하나의 보고서에 여러 개의 실체를 할당할 수 있다.예를 들어, 우리가 쓰는 죽은 저장소를 확보하기 위해

할당 해제(a, b) 

배열이 범위를 벗어나면 자동으로 배분이 해제된다.

요소 작업, 할당 및 절차

전체 어레이 할당 및 운영:

진짜, 치수(10) :: a, b a = 0.          ! 스칼라 방송, 요소 할당 b = SQRT(a)     ! 배열 개체로서의 내적 함수 결과 

두 번째 할당에서 내인 함수는 배열 값 인수에 대해 배열 값 결과를 반환한다.어레이 가치 함수를 직접 작성할 수 있음(명시 인터페이스 필요):

프로그램시험하다    진짜, 치수(3) :: a = (/ 1., 2., 3./),       &                          b = (/ 2., 2., 2. /),  r    r = f(a, b)    프린트 *, r 포함하다 함수f(c, d)    진짜, 치수(:) :: c, d    진짜, 치수(사이즈(c)) :: f    f = c*d        ! (또는 c와 d의 더 유용한 기능)    끝 함수f 종료 프로그램시험하다 

요소 절차는 배열 실제 인수로 호출할 수 있는 스칼라 더미 인수로 지정된다.함수의 경우 결과의 모양이 배열 인수의 형상이다.

대부분의 내재적 함수는 소자이며, Fortran 95는 이 기능을 비 내부적 절차로 확장하여 Fortran 90, 22개의 다른 버전에서 0-0, 0-1, 1-0, 0-2, 2-2, ... 7-7 순위에 대한 쓰기 효과를 제공하며, 병렬 프로세서에 대한 최적화를 더욱 보조한다.원소 절차는 순수해야 한다.

원소 서브루틴바꾸다(a, b)    진짜, 의도(인아웃)  :: a, b    진짜                 :: 일을 하다    일을 하다 = a    a = b    b = 일을 하다 서브루틴 끝바꾸다 

더미 인수는 특정 내적 함수에 대한 인수를 제외하고 사양 식(위 참조)에 사용할 수 없다.BIT_SIZE,KIND,LEN, 및 숫자 조회 항목(아래 참조).

어디에

종종, 우리는 과제를 숨길 필요가 있다.우리가 할 수 있는 것은WHERE, 진술로서 다음과 같다.

어디에 (a /= 0.0) a = 1.0/a  ! 0으로 나누지 마라. 

(참고: 테스트는 전체 배열이 아닌 요소별로 수행됨) 또는 구성으로:

어디에 (a /= 0.0)    a = 1.0/a    b = a             ! 모든 배열이 동일한 모양 종료 위치 

또는

어디에 (a /= 0.0)    a = 1.0/a 다른 곳    a = 거대(a) 종료 위치 

추가:

• 는 것뿐만 아니라WHERE에 대한 진술서WHERE을 건설하다.ELSEWHERE이 문서에 포함된 문장.
• a WHERE구성에는 임의 개수의 마스크된 항목이 포함될 수 있음ELSEWHERE하나밖에 없는 진술.ELSEWHERE마스크가 없는 진술, 이것이 마지막 진술이어야 한다.
• WHERE시공은 서로 내포될 수 있다.FORALL구성품;
• a WHERE할당 명세서는 소자일 경우 정의된 할당으로 허용된다.
• a WHERE구조는 다른 구조와 같은 방법으로 명명될 수 있다.

FORALL 문 및 구성

~할 때DO구성을 실행하며, 각 연속 반복은 순서대로 차례로 수행되며, 이는 병렬 프로세서에서 최적화를 방해하는 것이다.

포올(i = 1:n) a(i, i) = x(i) 

개별 과제를 순서와 동시에 수행할 수 있는 경우.그FORALL지수의 도움을 받아 표현된 배열 할당으로 간주될 수 있다.

포올(i=1:n, j=1:n, y(i,j)/=0.) x(j,i) = 1.0/y(i,j) 

마스킹 상태로

그FORALLconstruct는 여러 할당문을 순서대로 실행할 수 있도록 허용한다.

a(2:n-1,2:n-1) = a(2:n-1,1:n-2) + a(2:n-1,3:n) + a(1:n-2,2:n-1) + a(3:n,2:n-1) b(2:n-1,2:n-1) = a(2:n-1,2:n-1) 

배열 할당과 동일함

포올(i = 2:n-1, j = 2:n-1)    a(i,j) = a(i,j-1) + a(i,j+1) + a(i-1,j) + a(i+1,j)    b(i,j) = a(i,j) 모두 종료 

그FORALL버전은 더 읽기 쉽다.

할당 위치:FORALL배열 할당과 같다. 모든 표현식이 임의의 순서로 평가되고 임시 저장소에 보관된 다음 모든 할당이 임의의 순서로 수행된다.첫 번째 진술은 두 번째 진술이 시작되기 전에 완전히 완료되어야 한다.

A FORALL내포될 수 있으며, 다음이 포함될 수 있다.WHERE. a 내에서 참조되는 절차FORALL순수해야 한다.

배열 요소

간단한 경우, 주어진 경우

진짜, 치수(100, 100) :: a 

예를 들어, 우리는 하나의 요소를a(1, 1). 다음과 같은 파생 데이터 유형의 경우

유형fun_del    진짜u    진짜, 치수(3) :: du 끝 유형fun_del 

이러한 유형의 배열을 선언할 수 있음:

유형(fun_del), 치수(10, 20) :: 타르를 칠하다 

그리고 다음과 같은 참고문헌.tar(n, 2)fun_del 타입의 요소(스칼라!)이지만tar(n, 2)%du진짜 타입의 배열이 있고tar(n, 2)%du(2)그 한 요소야기억해야 할 기본 규칙은 배열 요소에는 최소한 성을 한정하는 첨자 또는 첨자가 항상 있다는 것이다.

배열 하위 객체(섹션)

배열 섹션의 일반적인 첨자 형식은

[하위] : [기울기] [:스트리드]

(여기서 [ ]는 선택 항목을 나타냄)과 같이

진짜a(10, 10) a(i, 1:n)                ! 한 줄의 부분 a(1:m, j)                ! 한 열의 일부 a(i, : )                 ! 전열 a(i, 1:n:3)              ! 행의 제3의 모든 요소들 a(i, 10:1:-1)            ! 역순으로 행하라. a( (/ 1, 7, 3, 2 /), 1)  ! 벡터 첨자 a(1, 2:11:2)             ! 11은 참조되지 않은 합법적 입니다. a(:, 1:7)                2등! 2등! 

값이 중복되는 벡터 첨자는 모호하기 때문에 할당 왼쪽에는 표시할 수 없다는 점에 유의하십시오.그러므로,

b( (/ 1, 7, 3, 7 /) ) = (/ 1, 2, 3, 4 /) 

불법이야또한 벡터 첨자가 있는 섹션은 실제 인수로 제공되어서는 안 된다.OUT또는INOUT허튼 수작배열 배열은 허용되지 않음:

타르를 칠하다%du             불법이야! 

우리는 배열의 주어진 값은 요소로서 그리고 하나의 섹션으로서 모두 참조될 수 있다는 점에 주목한다.

a(1, 1)            ! 스칼라 (0위) a(1:1, 1)          ! 배열 섹션(1위) 

상황이나 요건에 따라파생형 객체를 선별하여 앞에서 설명한 규칙에 따라 요소 또는 섹션을 얻는다.

타르를 칠하다%u              ! 배열 섹션(배열 구성 요소) 타르를 칠하다(1, 1)%u        ! 배열 요소의 구성 요소 

배열 내적 함수

벡터 및 행렬 곱하기

DOT_PRODUCT Dot 제품 2 순위 배열 MATMUL 매트릭스 곱하기

배열감소

모든 값이 참인 경우 모든 참 값이 참인 경우 모든 참.예: IF (AY( a > b) 그러면 배열의 참 요소 수 MAXVAL 최대값 배열의 최소값 수 배열 MINVAL 최소값 배열 요소 배열 요소의 SUM SUM SUM SUM

배열조회

할당된 배열 할당 상태 LBANDed 어레이 할당 상태 LBAND 어레이 SHAPE 쉐이프의 치수 하한 SIZE 배열의 총 요소 수 UBUND 어레이의 치수 상한

배열구축

마스크 팩에서 병합 마스크 아래의 병합 마스크 아래의 순위 배열로 어레이를 팩합니다. 차원 UNPACK을 추가하여 순위 배열의 포장을 마스크 아래의 배열로 푸십시오.

배열 재형

REFRAFE 어레이 재구성

배열 조작

CShift 원형 시프트 EOSHIFT 엔드오프 시프트 TROSPOose 2등급 배열의 전치

배열위치

배열 MINLOC 최대값의 MAXLOC 위치 배열에서 첫 번째 최소값의 위치

포인터

기본 사항

포인터는 다음이 포함된 변수POINTER속성; 그것들은 구별되는 데이터 유형이 아니다. 따라서 '산술'은 불가능하다.

진짜, 포인터 :: 시합을 하다 

이들은 포인터로 가리킬 수 있는 개체(표적)의 속성과 대상의 주소(있는 경우)를 나열하는 개념적으로 설명자다.이러한 저장소는 할당되거나 다른 방식으로 연결될 때까지 연결되지 않는다(포인터 할당을 통해 아래 참조:

할당하다 (시합을 하다) 

자동으로 참조 해제되므로 특별한 기호가 필요하지 않다.인

시합을 하다 = 시합을 하다 + 2.3 

var의 목표값을 사용하고 수정한다.포인터는 I/O를 통해 전송할 수 없다.성명서

쓰기 *, 시합을 하다 

포인터 설명자 자체가 아니라 var의 대상 값을 기록한다.

포인터는 다른 포인터를 가리킬 수 있으며, 따라서 대상을 가리킬 수도 있고, 또는 이 포인터가 있는 정적 객체를 가리킬 수도 있다.TARGET속성:

진짜, 포인터 :: 반대하다 진짜, 대상  :: target_obj 시합을 하다 => 반대하다                  ! 포인터 할당 시합을 하다 => target_obj 

그러나 다음과 같이 강하게 타이핑된다.

정수, 포인터 :: int_var 시합을 하다 => int_var                 ! 잘못된 유형 - 일치해야 함 

그리고, 마찬가지로, 배열의 경우 등급과 유형이 일치해야 한다.

포인터는 파생 형식의 구성 요소가 될 수 있다.

TYPE 입력                       ! 스파스 행렬의 유형    진짜가치를 매기다    정수색인을 달다    유형(입장권), 포인터 :: 다음에  ! 노트 재귀 종료 유형 항목 

그리고 우리는 그러한 항목들의 연결된 체인의 시작을 정의할 수 있다.

유형(입장권), 포인터 :: 쇠사슬을 매다 

적절한 할당과 정의 후에 처음 두 항목은 다음과 같이 처리될 수 있다.

쇠사슬을 매다%가치를 매기다쇠사슬을 매다%다음에%가치를 매기다 쇠사슬을 매다%색인을 달다쇠사슬을 매다%다음에%색인을 달다 쇠사슬을 매다%다음에            쇠사슬을 매다%다음에%다음에 

그러나 일반적으로 목록의 첫 번째 항목과 현재 항목을 가리키는 추가 포인터를 정의한다.

협회

포인터 연결 상태는 다음 중 하나임

의 사용으로 포인터를 '땡땡이'로 남기지 않도록 어느 정도 주의를 기울여야 한다.DEALLOCATE다른 포인터를 무효로 하지 않은 채 목표물에 도달한다.

고유함수ASSOCIATED정의된 포인터 연결 상태를 테스트할 수 있음:

IF (연관된(포인터)) 그럼 

또는 정의된 포인터와 정의된 대상(자체가 포인터가 될 수 있음):

IF (연관된(포인터, 표적으로 삼다)) 그럼 

명세서에서도 포인터를 초기화하기 위한 다른 방법은 다음을 사용하는 것이다.NULL함수:

진짜, 포인터, 치수(:) :: 벡터 => NULL() ! 컴파일 시간 벡터 => NULL()                                ! 런타임 

표현식 및 할당 포인터

본질적인 유형의 경우 데이터 이동 없이 동일한 코드를 사용하여 서로 다른 대상 데이터 집합에 대한 포인터를 '스위프'할 수 있다.매트릭스 조작 y = B C z를 고려할 때, 우리는 다음과 같은 코드를 쓸 수 있다(그러나, 이 경우, 동일한 결과가 다른 수단으로 보다 단순하게 달성될 수 있다).

진짜, 대상  :: b(10,10), c(10,10), r(10), s(10), z(10) 진짜, 포인터 :: a(:,:), x(:), y(:) 정수다중의 : DO다중의 = 1, 2    IF (다중의 == 1) 그럼       y => r              ! 데이터 이동 없음       a => c       x => z    기타       y => s              ! 데이터 이동 없음       a => b       x => r    엔디프    y = 맷물(a, x)       ! 공통 계산 종료 작업 

파생형 객체의 경우 포인터와 일반 할당을 구분해야 한다.인

유형(입장권), 포인터 :: 맨 처음의, 현재의 : 맨 처음의 => 현재의 

과제는 전류에 먼저 영향을 주는 반면,

맨 처음의 =  현재의 

전류가 먼저 덮어쓰게 하고 다음 값과 동일함

맨 처음의%가치를 매기다 = 현재의%가치를 매기다 맨 처음의%색인을 달다 = 현재의%색인을 달다 맨 처음의%다음에 => 현재의%다음에 

포인터 인수

실제 인수가 포인터인 경우, 더미 인수가 포인터인 경우,

• 계급이 같아야 해
• 실제 주장으로부터 연관성 상태를 수신한다.
• 최종 연결 상태를 실제 인수로 되돌린다(참고: 대상이 정의되지 않을 수 있음).
• 그것은 아마 이 없을 것이다.INTENT속성(불확실할 수 있음)
• 인터페이스 블록이 필요하다.

더미 인수가 포인터가 아닌 경우, 실제 인수의 대상과 연관된다.

   진짜, 포인터 :: a (:,:)       :    할당하다 (a(80, 80))       :    호출후보선수(a)       : 서브루틴후보선수(c)    진짜c(:, :) 

포인터 함수

함수 결과에는 다음이 포함될 수 있다.POINTER속성; 이것은 결과 크기가 함수에서 수행된 계산에 따라 달라지는 경우에 유용하다.

사용하다data_properties 진짜x(100) 진짜, 포인터 :: y(:) : y => 작은(x) 

여기서 모듈 data_properties는

함수작은(x)    진짜, 포인터 :: 작은(:)    진짜x(:)    ! 어레이에서 중복 항목을 제거하는 절차 x    정수n    :              ! 구별되는 값의 개수 찾기, n    할당하다(작은(n))    :              ! 구별되는 값을 압축으로 복사 끝 함수작은 

결과는 식에서 사용할 수 있지만 정의된 대상과 연관되어야 한다.

포인터 배열

다음과 같은 것은 존재하지 않는다: 주어진

유형(입장권) :: 노를 젓다(n) 

그때

노를 젓다%다음에              불법이야! 

그런 물체가 될 수도 있지만, 저장 패턴이 불규칙할 수도 있다.이런 이유로 그들은 허용되지 않는다.그러나 포인터가 있는 파생 데이터 유형을 유일한 구성요소로 정의함으로써 동일한 효과를 얻을 수 있다.

유형배를 젓다    진짜, 포인터 :: r(:) 끝 유형 

이 데이터 유형의 어레이 정의

유형(배를 젓다) :: s(n), t(n) 

예를 들어, 행에 대한 저장소를 할당할 수 있는 위치

DOi = 1, n    할당하다 (t(i)%r(1:i)) ! 길이의 행 i를 할당한다. 종료 작업 

배열 할당s = t그런 다음 포인터 할당과 동일함s(i)%r => t(i)%r모든 구성 요소에 대해.

동적 별칭으로서의 포인터

배열 지정

진짜, 대상 :: 테이블(100,100) 

고정된 첨자와 자주 참조되는

테이블(m:n, p:q) 

이 참고문헌은 다음에 의해 대체될 수 있다.

진짜, 치수(:, :), 포인터 :: 창문의    : 창문의 => 테이블(m:n, p:q) 

창의 첨자는1:n-m+1, 1:q-p+1마찬가지로.tar%u(이미 정의한 바와 같이), 우리는 이렇게 말할 수 있다.taru => tar%utar의 모든 u 구성 요소를 가리키고, 그것을 다음과 같이 첨자한다.taru(1, 2)