从OOP背景出发，咨询Forth类函数结构及单词定义变量使用方法

1. Does Forth have class/function-like structures? #

Forth doesn’t come with native class support like the OOP languages you’re familiar with, but it’s incredibly flexible—you can absolutely simulate class-like behavior using its core features. Here’s how:

• Vocabularies as namespaces: Use VOCABULARY to create separate namespaces, similar to how classes group related methods. This keeps your "class-specific" words organized:

  VOCABULARY Rectangle
  Rectangle DEFINITIONS
  
  : width ( -- addr ) 0 ;  \ Dummy address for demo—we’ll use a better approach next
  : height ( -- addr ) 1 ;
  : area ( -- n ) width @ height @ * ;
  
  \ Switch back to the default global vocabulary
  FORTH DEFINITIONS
  

• CREATE/DOES> for instance-based behavior: This is the go-to method for simulating objects with bundled data and behavior. You define a "constructor" that allocates storage for an instance, then a DOES> clause that defines how words interact with that instance’s data. Here’s a concrete rectangle example:

  \ Define a template for rectangle instances (2 cells for width + height)
  CREATE Rectangle 2 ALLOT
  
  \ Helper word to initialize a rectangle’s data
  : (init-rect) ( w h rect -- )
    OVER ! SWAP 1 CELLS + ! ;
  
  \ "Constructor" word: takes width/height, returns a new rectangle instance
  : new-rect ( w h -- rect )
    Rectangle HERE (init-rect) ;
  
  \ Method to calculate area from a rectangle instance
  : area ( rect -- n )
    DUP @ SWAP 1 CELLS + @ * ;
  
  \ Usage example
  5 3 new-rect area .  \ Outputs 15
  

Think of CREATE/DOES> pairs as a way to bundle data and behavior—core OOP principles—just without formal class syntax.

2. Can I use variables in Forth word definitions for complex functionality? #

Absolutely! Variables are a staple in Forth for building stateful or complex logic. Here’s how to work with them:

Global variables #

Use VARIABLE to define a global variable, then @ to read its value and ! to write to it. For example, a simple accumulator:

VARIABLE acc
: init-acc acc 0 ! ;  \ Initialize accumulator to 0
: add-to-acc ( n -- ) acc +! ;  \ Add input value to the accumulator
: get-acc ( -- n ) acc @ ;  \ Retrieve the current accumulator value

\ Usage
init-acc
5 add-to-acc
3 add-to-acc
get-acc .  \ Outputs 8

Local variables #

For more encapsulated logic, most modern Forth systems (like Gforth) support local variables. Use VALUE/TO for single values, or LOCAL for multiple locals:

\ Using VALUE/TO for a reusable local-like value
VALUE x
: set-x ( n -- ) TO x ;
: double-x ( -- n ) x 2 * ;

\ Using LOCAL (Gforth syntax) for block-scoped locals
: complex-calc ( a b -- result )
  LOCAL| a b |  \ Declare local variables matching input stack order
  a b + 3 *  \ Example calculation: (a + b) * 3
;

You can use variables inside loops, conditionals, or nested word definitions to track state, build data structures, or implement algorithms that require persistent values between operations. Forth doesn’t restrict you here—variables are a key tool for unlocking complex functionality.

内容的提问来源于stack exchange，提问作者Softey