프로그래밍/파스칼/기본서

program 프로그램이름; // 이 소스코드가 프로그램이라는것을 의미한다.
label                 // Goto문의 지표가 된다.
  지표1, 지표2;
 
uses                  // 외부유닛의 참조목록이다.
  유닛1, 유닛2;
 
type                  // 자료형 선언부이다.
  형명칭: 자료형; 
 
var                   // 변수 선언부이다.             
  변수명: 자료형;
 
const                 // 상수 선언부이다.
  상수명=상수값;
 
  procedure 프로시저이름; // 프로시저를 만들었다.
  begin                   // 시작
    명령;
  end;                    // 끝 - 프로시저
 
begin                 // 시작
  프로시저이름;
  명령;                     // end의 앞에는 원칙적으로는 ;이 오면 안된다. 이 문제는 나중에 다룬다.
end.                  // 끝 - 프로그램

program Helloworld;
begin
  WriteLn('HelloWorld');
end.

var
  a, b: Integer;
 
begin
  a := 40; // a = 40
  b := a;  // b = 40 : 40이 저장된 a의 값을 b에 대입했으므로 b의 값은 40이다.
end

var
  intA, intB: Integer;
  strA, strB: String;
 
begin
  intA := 1;
  intB := intA + 4; // intB = 5
  strA := 'Hello';
  strB := StrA + 'World'; // strB = 'HelloWorld'
end

var
  a, b: Integer;
 
begin
  a := 100;
  b := -a; // b = -100
end

var
  int: Integer;
  float: real;
 
begin
  int := 26 div 7; // int = 3 : 몫을 구했다.
  int := 26 mod 7; // int = 5 : 나머지를 구했다.
  float := 10 / 4; // float = 2.5 : 실수범위에서 나누었다.
  {int := 10 / 2;} // 나누면 5로 떨어지므로 int에 대입할 수 있을듯 하지만 /연산자는 실수값을 반환하므로 대입할 수 없다.
  int := trunc( 26 / 7 ); // int = 3 : 함수를 이용해 소수점 이하를 버렸다. 따라서 몫을 구한 것과 같다.
end

var
  is_bigger, is_in: Boolean;
 
begin
  is_bigger := 3 > 1; // is_bigger = True
  is_bigger := 100 > 100; // is_bigger = False
  is_in := 1 in [1, 3, 5, 10]; // is_in = True
end

var
  Num: Integer;
 
begin
  Num := 5; // 5, 00000101
  Num := Num SHL 2; // 20, 00010100, 왼쪽으로 두비트 밀리고 오른쪽이 0으로 채워졌다.
  Num := Num SHR 3; //  2, 00000010, 오른쪽으로 세비트 밀리고 왼쪽이 0으로 채워졌다. 마지막 1은 사라졌다.
end

type
  NewInteger = Integer;

var
  Int1, Int2: Integer;
  Card1, Card2: Cardinal;
 
begin
  Int1 := 10;
  Card1 := 5;
  Int2 := Int1 + Card1; // Integer 형으로 바뀌어 대입된다.
  Card := Int1 + Card2; // Cardinal 형으로 바뀌어 대입된다.
 
  Int1 := -3;
  Card1 := -10; // Cardinal은 음수를 가질 수 없으므로 컴파일 오류 발생.
  Card1 := 3;
  Int2 := Int1 + Card1; // 0 저장
  Card2 := Int1 + Card1; // 어쨌든 결과값이 0이므로 0이 저장된다.
 
  Int1 := -4;
  Card2 := Int1 + Card1; // 범위를 벗어나서 실행 오류 발생.
end
// 범위 불일치는 오류가 일어날 여지가 있으므로 이 예제의 모든 문장에서 경고가 발생한다.

type
  Wiki = (wikipedia, wikibooks, wiktionary, wiknews);
 
var
  Work: Wiki;
 
begin
  Work := wikibooks;
  if Work in [wikipedia, wikibooks, wiktionary] then // 열거형은 주로 집합형(Set)과 함께 쓰인다.
    writeLn('이 작업은 한국어 위키미디어 프로젝트가 존재한다.');
end

type
  Alphabet = 'A'..'z';
  NumberKey = 0..9;
 
var
  Chr: Alphaber; // 영문자의 대소문자만 가질 수 있다.
  IntKey: NumberKey; // 0부터 9까지의 한자리 숫자만 가질 수 있다.
 
begin
  IntKey := 5; // 일반적
  IntKey := 10; // 오류, 범위초과
end

var
  Int1, Int2: Integer;
  Float: Real;
 
begin
  Int1 := 5;
 
  Float := Int1; // 정수에서 실수로 대입은 가능하다.
  Int1 := Float; // 오류 발생! 같은경우처럼 보일지 모르나 실수형 자료는 정수에 대입할 수 없다. Float이 가진 값은 15000이지만 실수 형태로 저장되어 있다.
  Int2 := Int1 + Float // 위와 같은 이유로 안된다.
 
  Int2 := Int1 / Int1; // 오류 발생! / 연산자는 무조건 실수값을 반환하므로 오류가 발생한다.
  Int2 := Int1 div Int1; // 오류 발생! div 연산자는 정수값을 반환한다.
 
  Float := Int1 / Int1; // 바른 연산이다.
end

var
  str: String;
  chr: Char;
 
begin
  str := 'Hello World';
  chr := str[1]; //chr = 'H' 
end

var
  Chr1, Chr2: Char;
  Str: String;
 
begin
  Str := Chr1 + Chr2; // 문자를 합치면 무조건 문자열이 된다.
 
  Str := '';
  Chr1 := 'a';
  Chr2 := Str + Chr1; // 오류가 발생한다. 문자열과 문자의 합은 문자열이다. 실제 값(''+'a'='a')과는 관계없다.
  //문자열에서 +는 concat 함수와 같은 역할일 뿐이기 때문에 위와 같은 현상이 일어난다.
end

type
  이름: Array[시작값..끝값] of 자료형;

type
  IntArray: Array[1..10] of Integer;
 
var
  intMass: IntArray; // intMass[1], intMass[2], ... intMass[10] 까지의 변수를 모두 선언한 것과 같다.
  count: Integer;
 
begin
   For count := 1 to 10 do // 반복문을 이용해 배열 전체에 접근한다.
     IntMass[count] := 0;
end

type
이름 = Record
  필드1 : 자료형;
  필드2 : 자료형;
  필드3 : 자료형;
end;

type
  Subject = Record
    Pascal, PHP, Assembly : Integer;
  end;
 
  Student = Record  
    Score: Subject;
    Name: Array[0..8] of Char;
    Grade: Char;
  end;
 
var
  Student1, Student2: Student;
 
begin
  Student1.Name := 'student';
  with Student1.Score do
    begin
      readln(Pascal, PHP, Assembly);
      if Pascal + PHP + Assembly > 200 then
        Student1.Grade := 'A'
      else
        Student1.Grade := 'F';
    end;
 
  Student2.Score := Student1.Score; // Student2의 Score를 한꺼번에 대입했다.
end

type
  이름 = Set of 자료형; //단 자료형의 선택 가능한 수에 제약이 있다.

type
  wiki = (wikipedia, wikibooks, wiktionary, wikinews);
  wikis = Set of wiki;
 
var
  wikis1, wikis2: wikis;
  Check: Boolean;
 
begin
  wikis1 := [wikibooks, wikipedia, wiktionary];
  wikis2 := [wikipedia..wikibooks];          //서수형을 다루므로 구간 내의 원소를 한번에 넣을 수 있다.
  Check := wikis1=wikis2;                    // Check = True, 순서에 관계없이 내부 값만 확인한다.
  wikis1 := wikis1 + [wiktionary, wikinews]; // wikis1 = [wikipedia..wikinews] 이다. 합집합 연산.
  wikis2 := wikis1 - wikis2;                 // wikis2 = [wikinews] 이다. 차집합 연산.
 
  Check := wikis2 in wikis1                  // 오류! in 연산자는 원소를 위한 것이다.
  Check := wikibooks in wikis1               // Check = True
  Check := wikibooks in wikis2               // Check = False
  Check := wikis2 <= wikis1;                 // Check = True, 부분집합을 크기 비교 연산으로 구할 수 있다.
  wikis2 := wikis1*wikis2;                   // wikis2=[wikinews], 교집합을 구하는 연산이다.
end

if Bool then
  명령
else
  명령;

if Bool then
  begin
    명령1;
    명령2;
    명령3;
  end
else
  begin
    명령1;
    명령2;
    명령3;
  end;

case 서수형 of
  경우1 :
    명령1;
  경우2 :
    명령2;
  경우3 :
    명령3;
  else
    명령;
end;

var
  Index: Integer;
 
begin
  for Index := 1 to 100 do
    WriteLn(Index);
end

var
  Index: Integer;
 
begin
  for Index := 100 downto 1 do
    WriteLn(Index);
end

Index*2

while bool do
  명령;

var
  a: Integer;
 
begin
  a := 1;
  while a < 100 do
    a := a + 1;
end // a = 100

repeat
  명령1;
  명령2;
until bool;

var
  Index : Integer;
begin 
  for count := 1 to 20 do
    begin
      if Index mod 2 = 0 then
        WriteLn(count)
      else
        Continue;
      if Index = 9 then
        Break;
      if Index = 12 then
        Break;
    end;
end

type
  RecSample = Record
    Chr1, Chr2: Char;
    Int1, Int2: Integer;
  end;
 
  TSample = class
    Chr1, Chr2: Char;
    Int1, Int2: Integer;
  end;
 
var
  varRecord: RecSample;
  varClass: TSample;
 
begin
  varRecord.Chr1 := 'a';
  varRecord.Chr2 := 'b';
 
  with varRecord do begin
    Int1 := 1;
    Int2 := 2;
  end;
 
  varClass := TSample.Create; // 이 부분은 클래스에서 설명한다.
  varClass.Chr1 := 'c';
  varClass.Int1 := 3;
 
  with varClass do begin
    Chr2 := varRecord.Chr2;
    Int2 := varRecord.Int2;
  end;
 
  varClass.Free; // 이 부분은 클래스에서 설명한다.
end

function 이름(인자: 인자자료형): 자료형;
begin
  연산;
  연산;
  Result := 함수값;
end;

Program Callfunction;
  function PlusMinus(a, b: Integer; Operator: Char): Integer;
    function Infunction: Integer;
    begin
      // 서브루틴 안에도 서브루틴을 만들 수 있다.
      Result := 함수값;
    end // of Infunction
  begin
    Result := 0; // 기본값을 0으로 지정한다.
    case Operator of
      '+' :
        Result := a + b;
      '-' : 
        Result := a - b;
    end; // of case 연산자가 '+'나 '-'가 아니면 기본값으로 남는다.
  end; // of PlusMinus
begin
  PlusMinus(1, 2, '+'); // 함수는 실행되었고 실제로 하드웨어에서 연산도 일어났다. 하지만 결과를 이용하지 않아 아무런 결과도 나타나지 않다.
  WriteLn(PlusMinus(1, 4, '+'));
end.

procedure 이름(인자: 인자자료형);
begin
  연산;
  연산;
end

Program 이름;
var
  A: 자료형; // 전역변수를 선언한다.
  procedure 이름;
  var
    A, B: 자료형; // 지역변수를 선언한다.
  begin
    명령; // A를 참조할 경우 프로시저 내의 A를 가리키게 된다. 이름이 중복될 경우 좁은지역의 변수가 우선한다.
  end;
begin
  명령; // B를 참조할 수 없다. B는 프로시저 내에서만 통용된다.
end.

function 이름(var 인자: 자료형): 자료형;
begin
  Result := 반환값;
end;

function 이름(const 인자: 자료형): 자료형;
begin
  Result := 반환값;
end;

procedure Proc1;
begin
  Proc2; // 정의되지 않은 식별자 오류
end;
 
procedure Proc2;
begin
  Proc1;
end;

procedure Proc2; forward;
 
procedure Proc1;
begin
  Proc2;
end;
 
procedure Proc2;
begin
  Proc1;
end;

unit Unitname;
 
interface
 
var
  int1: Integer; // 이 유닛을 참조하면 interface에 선언한 내용은 접근할 수 있다.
 
procedure Proc1; // interface에서는 이름만 선언해 준다.
 
implementation
 
var
  int2: Integer; // implementation에 선언한 내용은 유닛 내에서만 접근할 수 있다. 이 기능으로 소스코드를 보호할 수 있다.
  procedure Proc1; // interface에서 선언한 부분을 implementation에서 구현한다.
  begin
 
  end;
end.

type
  TClassName = class
    int1: Integer; // 일반적 변수 선언
  private
    int2: Integer;
  protected
    int3: Integer;
  public
    int4: Integer;
    constructor create;
    destructor destroy;
  end;

type
  TClassName = class
  private
    procedure Proc1; virtual; // private이므로 virtual로 선언할 필요가 없다.
  protected
    procedure Proc2; virtual;
  public
    procedure Proc3; virtual;
  end;
 
  TClassName2 = class(TClassName)
  public
    procedure Proc1: override; // private로 선언한것은 override할 수 없다.
    procedure Proc2: override;
    procedure Proc3: override;
  end;
 
var
  ClassExam: TClassName;
 
procedure Proc4;
begin
  ClassExam := TClassName.Create;
  Proc1; // Private로 선언한 것을 호출할 수 없다.
  Proc2; // Protected로 선언한 것을 호출할 수 없다.
  Proc3; // Public으로 선언했으므로 호출할 수 있다.
  ClassExam.Destroy; // 일반적으로 TObject를 제거할때는 Free를 호출한다.
end;

var
  ClassExam: TclassName;

ClassExam.Create;

type
  TClassParent = Class
  public
    int1: Integer;
    procedure Proc1; virtual;
  end;
 
  TClassName = Class(TClassParent)
  public
    procedure Proc2: override;
  end;
 
procedure TclassParent.Proc1;
begin
 
end;
 
procedure TclassName.Proc1;
begin
  inherited; // inherited 자리에서 이 클래스가 상속한 TClassParent.Proc1이 실행된다.
 
end;