Uwaga: stos w programie jest zrealizowany za pomocą tablicy. Na początku należy określić stałą MAX_S, tak aby dane zmieściły się w tablicy – wartość 100 powinna wystarczyć dla większości wyrażeń. Program nie sprawdza poprawności wyrażeń ONP, dlatego należy uważać przy ich wprowadzaniu.

// Obliczanie wyrażenia ONP
// Data: 18.08.2012
// (C)2020 mgr Jerzy Wałaszek
//---------------------------

program rpn_eval;

const MAX_S = 100; // maksymalny rozmiar stosu

var
  S : array [0..MAX_S-1] of double; // stos
  p : integer; // wskaźnik stosu
  e : string; // element wyrażenia ONP
  v1, v2 : double; // argumenty operacji
  c : word; // pozycja błędu przy konwersji

begin

  p := 0; // inicjujemy stos;

  repeat  // przetwarzamy wyrażenie ONP
    readln(e); // element wyrażenia ONP
    if e = '=' then break; // koniec wyrażenia ONP
    val(e, v1, c); // dokonujemy konwersji
    if c = 0 then
    begin // liczba
      S[p] := v1; // umieszczamy ją na stosie
      inc(p); // zwiększamy wskaźnik stosu
    end
    else
    begin // operator
      v1 := S[p-2]; // pobieramy ze stosu
      v2 := S[p-1]; // dwa argumenty
      case e of // wykonujemy operacje wg operatora
        '+' : v1 := v1+v2;
        '-' : v1 := v1-v2;
        '*' : v1 := v1*v2;
        '/' : v1 := v1/v2;
      end;
      S[p-2] := v1; // wynik na stos
      dec(p); // ze stosu znika jedna liczba
    end;
  until false; // pętla nieskończona

  writeln(S[p-1]:0:6); // wypisujemy wynik
end.

// Obliczanie wyrażenia ONP
// Data: 18.08.2012
// (C)2020 mgr Jerzy Wałaszek
//---------------------------

#include <iostream>
#include <sstream>
#include <iomanip>
#include <string>

using namespace std;

const int MAX_S = 100; // rozmiar stosu

int main()
{
  double S[MAX_S]; // stos
  int p = 0; // wskaźnik stosu
  string e; // element wyrażenia ONP
  double v1, v2; // argumenty operacji
  stringstream ss; // strumień łańcuchowy

  cout << fixed;

  while(true) // przetwarzamy wyrażenie ONP
  {
    getline(cin, e);
    if(e == "=") break; // koniec wyrażenia?
    ss.str(""); // usuwamy wszelki tekst ze strumienia
    ss.clear(); // czyścimy błędy konwersji
                // z poprzednich wywołań
    ss << e; // odczytany element umieszczamy
             // w strumieniu

    if(ss >> v1) // konwertujemy na liczbę i sprawdzamy, 
                 // czy nie było błędu
                 // liczba
      S[p++] = v1; // umieszczamy ją na stosie
    else
    { // operator
      v2 = S[--p]; // pobieramy ze stosu dwa argumenty
      v1 = S[--p];
      switch(e[0]) // wykonujemy operacje wg operatora
      {
        case '+' : v1 += v2; break;
        case '-' : v1 -= v2; break;
        case '*' : v1 *= v2; break;
        case '/' : v1 /= v2; break;
      }
      S[p++] = v1; // wynik umieszczamy na stosie
    }
  }
  cout << S[--p] << endl; // wypisujemy wynik
  return 0;
}

' Obliczanie wyrażenia ONP
' Data: 18.08.2012
' (C)2020 mgr Jerzy Wałaszek
'---------------------------

Const MAX_S = 100 ' rozmiar stosu

Dim S(MAX_S-1) As Double ' stos
Dim p As Integer ' wskaźnik stosu
Dim e As String ' element wyrażenia ONP
Dim As Double v1, v2 ' argumenty operacji

Open Cons For Input As #1

p = 0 ' inicjujemy stos
While 1 ' przetwarzamy wyrażenie ONP
  Input #1, e ' odczytujemy element wyrażenia ONP
  If e = "=" Then Exit While ' koniec?
  v1 = Val(e)  ' dokonujemy konwersji
  If v1 <> 0 OrElse Left(e, 1) = "0" Then
    ' liczba
    S(p) = v1 ' umieszczamy ją na stosie
    p += 1 ' zwiększamy wskaźnik stosu
  Else
    ' operator
    v1 = S(p-2) ' pobieramy ze stosu dwa argumenty
    v2 = S(p-1)
    Select Case e ' wykonujemy operacje wg operatora
      Case "+": v1 = v1+v2
      Case "-": v1 = v1-v2
      Case "*": v1 = v1 * v2
      Case "/": v1 = v1 / v2
    End Select
    S(p-2) = v1 ' wynik umieszczamy na stosie
    p -= 1 ' ze stosu znika jedna liczba
  End If
Wend
Close #1
Print Using "&";S(p-1) ' wypisujemy wynik
End

// Przekształcanie wyrażenia na ONP
// Data: 19.08.2012
// (C)2020 mgr Jerzy Wałaszek
//---------------------------------

program project1;

const S_MAX = 100; // rozmiar stosu

// Zwraca priorytet operatora
//---------------------------

function p(c : char) : integer;
begin
  case c of
   '('      : p := 0;
   '+', '-' : p := 1;
   '*', '/' : p := 2;
   '^'      : p := 3;
   end;
end;

//------------------------------------
// Tutaj rozpoczyna się program główny
//------------------------------------

var
  S : array [0..S_MAX-1] of char; // stos
  sptr : integer; // wskaźnik stosu
  c : char; // kolejny znak wyrażenia

begin
  sptr := 0; // inicjujemy stos

  while true do
  begin
    read(c); // czytamy znak z wejścia
    if c = '=' then // koniec wyrażenia?
    begin
      while sptr > 0 do
      begin
        dec(sptr); // jeśli tak, na wyjście przesyłamy
        write(S[sptr], ' '); // całą zawartość stosu
      end;
      break; // i przerywamy pętlę
    end;

    case c of // analizujemy odczytany znak
    ' ' : ; // spację ignorujemy
    '(' : begin // nawias "(" zawsze na stos
            S[sptr] := '(';
            inc(sptr);
          end;
    ')' : begin // nawias zamykający
            while S[sptr-1] <> '(' do
            begin
              // ze stosu przesyłamy na wyjście
              // wszystkie operatory aż do nawiasu "("
              dec(sptr);
              write(S[sptr], ' ');
            end;
            // usuwamy ze stosu nawias otwierający
            dec(sptr);
          end;
    '+', '-', '*', '/', '^' : // operator
          begin
            while sptr > 0 do
            begin
              if(p(c) = 3) or (p(c) > p(S[sptr-1])) then
                break;
              // na wyjście przesyłamy ze stosu
              // wszystkie operatory
              // o wyższych priorytetach
              dec(sptr);
              write(S[sptr], ' ');
            end;
            // operator umieszczamy na stosie
            S[sptr] := c;
            inc (sptr);
          end;
    else
      // inaczej znak przesyłamy na wyjście
      write(c, ' ');
    end;
  end;
  writeln;
end.

// Przekształcanie wyrażenia na ONP
// Data: 19.08.2012
// (C)2020 mgr Jerzy Wałaszek
//---------------------------------

#include <iostream>

using namespace std;

const int S_MAX = 100; // rozmiar stosu

// Zwraca priorytet operatora
//---------------------------

int p(char c)
{
  switch(c)
  {
    case '+'     :
    case '-'     : return 1;
    case '*'     :
    case '/'     : return 2;
    case '^'     : return 3;
  }
  return 0;
}

//------------------------------------
// Tutaj rozpoczyna się program główny
//------------------------------------

int main()
{
  char S [S_MAX]; // stos operatorów
  int sptr = 0; // wskaźnik stosu
  char c; // kolejny znak wyrażenia

  while(true)
  {
    cin >> c; // czytamy znak z wejścia

    if(c == '=') // koniec wyrażenia?
    {
      while(sptr)
        cout << S[--sptr] << ' '; // jeśli tak, 
        // na wyjście przesyłamy wszystkie
        // operatory ze stosu i przerywamy pętlę
      break;
    }

    switch (c) // analizujemy odczytany znak
    {
      case ' ' : break; // spację ignorujemy
      case '(' : S[sptr++] = '(';
                 // nawias "(" zawsze na stos
                 break;
      case ')' : while(S[sptr-1] != '(') // nawias ")"
                 cout << S[--sptr] << ' '; // ze stosu
                 // przesyłamy na wyjście wszystkie
                 // operatory aż do nawiasu "("
                 sptr--; // usuwamy ze stosu
                         // nawias "("
                 break;
      case '+' : // operator
      case '-' :
      case '*' :
      case '/' :
      case '^' : while(sptr)
                 {
                   if((p(c) == 3) ||
                      (p(c) > p(S[sptr-1]))) break;
                   cout << S[--sptr] << ' '; 
                 } // na wyjście przesyłamy ze stosu
                   // operatory o wyższych priorytetach
                 S[sptr++] = c; // operator umieszczamy
                                // na stosie
                 break;
      default:   cout << c << ' '; // inaczej znak
                                   // przesyłamy
                                   // na wyjście
                 break;
    }
  }
  cout << endl;
  return 0;
}

' Przekształcanie wyrażenia na ONP
' Data: 19.08.2012
' (C)2020 mgr Jerzy Wałaszek
'------------------------------

Const S_MAX = 100 ' rozmiar stosu operatorów

' Zwraca priorytet operatora
'---------------------------
Function p (c As String) As Integer
  Select Case c
         Case "("
           p = 0
         Case "+", "-"
           p = 1
         Case "*", "/"
           p = 2
         Case "^"
           p = 3
  End Select
End Function

Dim S (S_MAX) As String * 1 ' stos operatorów
Dim sptr As Integer ' wskaźnik stosu
Dim c As String * 1 ' kolejny znak wyrażenia
Dim t As String ' przechowuje wczytany wiersz
Dim i As Integer ' indeks

Open Cons For Input As #1
sptr = 0 ' inicjujemy stos
Line Input #1, t ' odczytujemy tekst
i = 1 ' indeks na pierwszy znak tekstu
Close #1
While 1
  c = Mid(t, i, 1) ' czytamy znak
  i += 1 ' przesuwamy się na następną pozycję

  If c = "=" then ' koniec wyrażenia?
    while sptr > 0
      sptr -= 1 ' jeśli tak, na wyjście przesyłamy
      Print S(sptr);" "; ' całą zawartość stosu
    Wend
    Exit While ' i przerywamy pętlę
  End If

  Select Case c ' analizujemy odczytany znak
         Case " " ' spację ignorujemy
         Case "(" ' nawias otwierający zawsze na stos
           S(sptr) = "("
           sptr += 1
         Case ")" ' nawias zamykający
           While S(sptr-1) <> "("
             sptr -= 1 ' ze stosu przesyłamy
             Print S(sptr);" "; ' na wyjście wszystkie
                                ' operatory aż do nawiasu otw.
           Wend
           sptr -= 1 ' usuwamy ze stosu nawias otwierający
         Case "+", "-", "*", "/", "^" ' operator
           while(sptr > 0)
           	 if(p(c) = 3) OrElse (p(c) > p(S(sptr-1))) Then _
               Exit While
             sptr -= 1 ' na wyjście przesyłamy ze stosu
             Print S(sptr);" "; ' wszystkie operatory
                                ' o wyższych priorytetach
           Wend
           S(sptr) = c ' operator umieszczamy na stosie
           sptr += 1
    Case Else
         Print c;" "; ' inaczej znak przesyłamy na wyjście
  End Select
Wend
Print
End