C++ switch..case Statement

In this tutorial, we will learn about switch statement and its working in C++ programming with the help of some examples.

The switch statement allows us to execute a block of code among many alternatives.

The syntax of the switch statement in C++ is:

switch (expression)  {
    case constant1:
        // code to be executed if 
        // expression is equal to constant1;
        break;

    case constant2:
        // code to be executed if
        // expression is equal to constant2;
        break;
        .
        .
        .
    default:
        // code to be executed if
        // expression doesn't match any constant
}

How does the switch statement work?

The expression is evaluated once and compared with the values of each case label.

  • If there is a match, the corresponding code after the matching label is executed. For example, if the value of the variable is equal to constant2, the code after case constant2: is executed until the break statement is encountered.
  • If there is no match, the code after default: is executed.

Note: We can do the same thing with the if...else..if ladder. However, the syntax of the switch statement is cleaner and much easier to read and write.


Flowchart of switch Statement

C++ switch...case flowchart
Flowchart of C++ switch…case statement

Example: Create a Calculator using the switch Statement

// Program to build a simple calculator using switch Statement
#include <iostream>
using namespace std;

int main() {
    char oper;
    float num1, num2;
    cout << "Enter an operator (+, -, *, /): ";
    cin >> oper;
    cout << "Enter two numbers: " << endl;
    cin >> num1 >> num2;

    switch (oper) {
        case '+':
            cout << num1 << " + " << num2 << " = " << num1 + num2;
            break;
        case '-':
            cout << num1 << " - " << num2 << " = " << num1 - num2;
            break;
        case '*':
            cout << num1 << " * " << num2 << " = " << num1 * num2;
            break;
        case '/':
            cout << num1 << " / " << num2 << " = " << num1 / num2;
            break;
        default:
            // operator is doesn't match any case constant (+, -, *, /)
            cout << "Error! The operator is not correct";
            break;
    }

    return 0;
}

Run Code

Output 1

Enter an operator (+, -, *, /): +
Enter two numbers: 
2.3
4.5
2.3 + 4.5 = 6.8

Output 2

Enter an operator (+, -, *, /): -
Enter two numbers: 
2.3
4.5
2.3 - 4.5 = -2.2

Output 3

Enter an operator (+, -, *, /): *
Enter two numbers: 
2.3
4.5
2.3 * 4.5 = 10.35

Output 4

Enter an operator (+, -, *, /): /
Enter two numbers: 
2.3
4.5
2.3 / 4.5 = 0.511111

Output 5

Enter an operator (+, -, *, /): ?
Enter two numbers: 
2.3
4.5
Error! The operator is not correct.

In the above program, we are using the switch...case statement to perform addition, subtraction, multiplication, and division.

How This Program Works

Notice that the break statement is used inside each case block. This terminates the switch statement.

If the break statement is not used, all cases after the correct case are executed.

  1. We first prompt the user to enter the desired operator. This input is then stored in the char variable named oper.
  2. We then prompt the user to enter two numbers, which are stored in the float variables num1 and num2.
  3. The switch statement is then used to check the operator entered by the user:
    • If the user enters +, addition is performed on the numbers.
    • If the user enters -, subtraction is performed on the numbers.
    • If the user enters *, multiplication is performed on the numbers.
    • If the user enters /, division is performed on the numbers.
    • If the user enters any other character, the default code is printed.

C++ comments line

In this tutorial, we will learn about C++ comments, why we use them, and how to use them with the help of examples.

C++ comments are hints that a programmer can add to make their code easier to read and understand. They are completely ignored by C++ compilers.

There are two ways to add comments to code:

// – Single Line Comments

/* */ -Multi-line Comments


Single Line Comments

In C++, any line that starts with // is a comment. For example,

// declaring a variable
int a;

// initializing the variable 'a' with the value 2
a = 2;

Here, we have used two single-line comments:

  • // declaring a variable
  • // initializing the variable 'a' with the value 2

We can also use single line comment like this:

int a;    // declaring a variable

Multi-line comments

In C++, any line between /* and */ is also a comment. For example,

/* declaring a variable
to store salary to employees
*/
int salary = 2000;

This syntax can be used to write both single-line and multi-line comments.


Using Comments for Debugging

Comments can also be used to disable code to prevent it from being executed. For example,

#include <iostream>
using namespace std;
int main() {
   cout << "some code";
   cout << ''error code;
   cout << "some other code";

   return 0;
}

If we get an error while running the program, instead of removing the error-prone code, we can use comments to disable it from being executed; this can be a valuable debugging tool.

#include <iostream>
using namespace std;
int main() {
   cout << "some code";
   // cout << ''error code;
   cout << "some other code";

   return 0;
}

Pro Tip: Remember the shortcut for using comments; it can be really helpful. For most code editors, it’s Ctrl + / for Windows and Cmd + / for Mac.


Why use Comments?

If we write comments on our code, it will be easier for us to understand the code in the future. Also, it will be easier for your fellow developers to understand the code.

Note: Comments shouldn’t be the substitute for a way to explain poorly written code in English. We should always write well-structured and self-explanatory code. And, then use comments.

As a general rule of thumb, use comments to explain Why you did something rather than How you did something, and you are good.

C++ Type Conversion

In this tutorial, we will learn about the basics of C++ type conversion with the help of examples.

C++ allows us to convert data of one type to that of another. This is known as type conversion.

There are two types of type conversion in C++.

  1. Implicit Conversion
  2. Explicit Conversion (also known as Type Casting)

Implicit Type Conversion

The type conversion that is done automatically done by the compiler is known as implicit type conversion. This type of conversion is also known as automatic conversion.

Let us look at two examples of implicit type conversion.


Example 1: Conversion From int to double

// Working of implicit type-conversion

#include <iostream>
using namespace std;

int main() {
   // assigning an int value to num_int
   int num_int = 9;

   // declaring a double type variable
   double num_double;
 
   // implicit conversion
   // assigning int value to a double variable
   num_double = num_int;

   cout << "num_int = " << num_int << endl;
   cout << "num_double = " << num_double << endl;

   return 0;
}

Run Code

Output

num_int = 9
num_double = 9

In the program, we have assigned an int data to a double variable.

num_double = num_int;

Here, the int value is automatically converted to double by the compiler before it is assigned to the num_double variable. This is an example of implicit type conversion.


Example 2: Automatic Conversion from double to int

//Working of Implicit type-conversion

#include <iostream>
using namespace std;

int main() {

   int num_int;
   double num_double = 9.99;

   // implicit conversion
   // assigning a double value to an int variable
   num_int = num_double;

   cout << "num_int = " << num_int << endl;
   cout << "num_double = " << num_double << endl;

   return 0;
}

Run Code

Output

num_int = 9
num_double = 9.99

In the program, we have assigned a double data to an int variable.

num_double = num_int;

Here, the double value is automatically converted to int by the compiler before it is assigned to the num_int variable. This is also an example of implicit type conversion.

Note: Since int cannot have a decimal part, the digits after the decimal point is truncated in the above example.


Data Loss During Conversion (Narrowing Conversion)

As we have seen from the above example, conversion from one data type to another is prone to data loss. This happens when data of a larger type is converted to data of a smaller type.

Data loss in C++ if a larger type of data is converted to a smaller type.
Possible Data Loss During Type Conversion

C++ Explicit Conversion

When the user manually changes data from one type to another, this is known as explicit conversion. This type of conversion is also known as type casting.

There are three major ways in which we can use explicit conversion in C++. They are:

  1. C-style type casting (also known as cast notation)
  2. Function notation (also known as old C++ style type casting)
  3. Type conversion operators

C-style Type Casting

As the name suggests, this type of casting is favored by the C programming language. It is also known as cast notation.

The syntax for this style is:

(data_type)expression;

For example,

// initializing int variable
int num_int = 26;

// declaring double variable
double num_double;

// converting from int to double
num_double = (double)num_int;

Function-style Casting

We can also use the function like notation to cast data from one type to another.

The syntax for this style is:

data_type(expression);

For example,

// initializing int variable
int num_int = 26;

// declaring double variable
double num_double;

// converting from int to double
num_double = double(num_int);

Example 3: Type Casting

#include <iostream>

using namespace std;

int main() {
    // initializing a double variable
    double num_double = 3.56;
    cout << "num_double = " << num_double << endl;

    // C-style conversion from double to int
    int num_int1 = (int)num_double;
    cout << "num_int1   = " << num_int1 << endl;

    // function-style conversion from double to int
    int num_int2 = int(num_double);
    cout << "num_int2   = " << num_int2 << endl;

    return 0;
}

Run Code

Output

num_double = 3.56
num_int1   = 3
num_int2   = 3

We used both the C style type conversion and the function-style casting for type conversion and displayed the results. Since they perform the same task, both give us the same output.


Type Conversion Operators

Besides these two type castings, C++ also has four operators for type conversion. They are known as type conversion operators. They are:

  • static_cast
  • dynamic_cast
  • const_cast
  • reinterpret_cast

We will learn about these casts in later tutorials.


Recommended Tutorials:

  • C++ string to int and Vice-versa
  • C++ string to float, double and Vice-versa

C++ Variables ,Constants and literals

In this tutorial, we will learn about variables, literals, and constants in C++ with the help of examples.

C++ Variables

In programming, a variable is a container (storage area) to hold data.

To indicate the storage area, each variable should be given a unique name (identifier). For example,

int age = 14;

Here, age is a variable of the int data type, and we have assigned an integer value 14 to it.

Note: The int data type suggests that the variable can only hold integers. Similarly, we can use the double data type if we have to store decimals and exponentials.

We will learn about all the data types in detail in the next tutorial.

The value of a variable can be changed, hence the name variable.

int age = 14;   // age is 14
age = 17;       // age is 17


Rules for naming a variable

  • A variable name can only have alphabets, numbers and the underscore _.
  • A variable name cannot begin with a number.
  • Variable names cannot begin with an uppercase character.
  • A variable name cannot be a keyword. For example, int is a keyword that is used to denote integers.
  • A variable name can start with an underscore. However, it’s not considered a good practice.

Note: We should try to give meaningful names to variables. For example, first_name is a better variable name than fn.


C++ Literals

Literals are data used for representing fixed values. They can be used directly in the code. For example: 12.5'c' etc.

Here, 12.5 and 'c' are literals. Why? You cannot assign different values to these terms.

Here’s a list of different literals in C++ programming.


1. Integers

An integer is a numeric literal(associated with numbers) without any fractional or exponential part. There are three types of integer literals in C programming:

  • decimal (base 10)
  • octal (base 8)
  • hexadecimal (base 16)

For example:

Decimal: 0, -9, 22 etc
Octal: 021, 077, 033 etc
Hexadecimal: 0x7f, 0x2a, 0x521 etc

In C++ programming, octal starts with a 0, and hexadecimal starts with a 0x.


2. Floating-point Literals

A floating-point literal is a numeric literal that has either a fractional form or an exponent form. For example:

-2.0

0.0000234

-0.22E-5

Note: E-5 = 10-5


3. Characters

A character literal is created by enclosing a single character inside single quotation marks. For example: 'a''m''F''2''}' etc.


4. Escape Sequences

Sometimes, it is necessary to use characters that cannot be typed or has special meaning in C++ programming. For example, newline (enter), tab, question mark, etc.

In order to use these characters, escape sequences are used.

Escape SequencesCharacters
\bBackspace
\fForm feed
\nNewline
\rReturn
\tHorizontal tab
\vVertical tab
\\Backslash
\'Single quotation mark
\"Double quotation mark
\?Question mark
\0Null Character

5. String Literals

A string literal is a sequence of characters enclosed in double-quote marks. For example:

"good"string constant
""null string constant
" "string constant of six white space
"x"string constant having a single character
"Earth is round\n"prints string with a newline

We will learn about strings in detail in the C++ string tutorial.


C++ Constants

In C++, we can create variables whose value cannot be changed. For that, we use the const keyword. Here’s an example:

const int LIGHT_SPEED = 299792458;
LIGHT_SPEED = 2500 // Error! LIGHT_SPEED is a constant.

Here, we have used the keyword const to declare a constant named LIGHT_SPEED. If we try to change the value of LIGHT_SPEED, we will get an error.

A constant can also be created using the #define preprocessor directive. We will learn about it in detail in the C++ Macros tutorial.

C Keywords and identifiers

In this tutorial, you will learn about keywords; reserved words in C programming that are part of the syntax. Also, you will learn about identifiers and how to name them.

Character set

A character set is a set of alphabets, letters and some special characters that are valid in C language.

Alphabets

Uppercase: A B C ................................... X Y Z
Lowercase: a b c ...................................... x y z

C accepts both lowercase and uppercase alphabets as variables and functions.

Digits

0 1 2 3 4 5 6 7 8 9

Special Characters

,<>._
();$:
%[]#?
&{}
^!*/|
\~+ 

White space Characters

Blank space, newline, horizontal tab, carriage, return and form feed.


C Keywords

Keywords are predefined, reserved words used in programming that have special meanings to the compiler. Keywords are part of the syntax and they cannot be used as an identifier. For example:

int money;

Here, int is a keyword that indicates money is a variable of type int (integer).

As C is a case sensitive language, all keywords must be written in lowercase. Here is a list of all keywords allowed in ANSI C.

autodoubleintstruct
breakelselongswitch
caseenumregistertypedef
charexternreturnunion
continueforsignedvoid
doifstaticwhile
defaultgotosizeofvolatile
constfloatshortunsigned

All these keywords, their syntax, and application will be discussed in their respective topics. However, if you want a brief overview of these keywords without going further, visit List of all keywords in C programming.


C Identifiers

Identifier refers to name given to entities such as variables, functions, structures etc.

Identifiers must be unique. They are created to give a unique name to an entity to identify it during the execution of the program. For example:

int money;
double accountBalance;

Here, money and accountBalance are identifiers.

Also remember, identifier names must be different from keywords. You cannot use int as an identifier because int is a keyword.


Rules for naming identifiers

  1. A valid identifier can have letters (both uppercase and lowercase letters), digits and underscores.
  2. The first letter of an identifier should be either a letter or an underscore.
  3. You cannot use keywords as identifiers.
  4. There is no rule on how long an identifier can be. However, you may run into problems in some compilers if the identifier is longer than 31 characters.

You can choose any name as an identifier if you follow the above rule, however, give meaningful names to identifiers that make sense. 

List of programming languages.

Computer programming languages are used to to communicate instructions to a computer. They are based on certain syntactic and semantic rules, which define the meaning of each of the programming language constructs.Today I’ve got a list of every programming language I could find. I divided them into the following categories:

  • Interpreted Programming Languages
  • Functional Programming Languages
  • Compiled Programming Languages
  • Procedural Programming Languages
  • Scripting Programming Languages
  • Markup Programming Languages
  • Logic-Based Programming Languages
  • Concurrent Programming Languages
  • Object-Oriented Programming Languages
A
A.NET
A-0 System
A+
ABAP
ABC
ABC ALGOL
ACC
Accent
Ace DASL
Action!
ActionScript
Actor
Ada
Adenine
Agda
Agilent VEE
Agora
AIMMS
Aldor
Alef
ALF
ALGOL 58
ALGOL 60
ALGOL 68
ALGOL W
Alice
Alma-0
AmbientTalk
Amiga E
AMOS
AMPL
AngelScript
Apex
APL

AppleScript
APT
Arc
ARexx
Argus
Assembly language
AutoHotkey
AutoIt
AutoLISP / Visual LISP
Averest
AWK
Axum
B
B
Babbage
Ballerina
Bash
BASIC
Batch file (Windows/MS-DOS)
bc
BCPL
BeanShell
Bertrand
BETA
BLISS
Blockly
BlooP
Boo
Boomerang
Bosque
Bourne shell (including bash and ksh)
K
K
Kaleidoscope
Karel
KEE
Kixtart
Klerer-May System
KIF
Kojo
Kotlin
KRC
KRL
KRL (KUKA Robot Language)
KRYPTON
Korn shell (ksh)
Kodu
Kv
L
LabVIEW
Ladder
LANSA
Lasso
Lava
LC-3
Legoscript
LIL
LilyPond
Limbo
Limnor
LINC
Lingo
LINQ
LIS
LISA
Language H
Lisp – ISO/IEC 13816
Lite-C
Lithe
Little b
LLL
Logo
Logtalk
LotusScript
LPC
LSE
LSL
LiveCode
LiveScript
Lua
Lucid
Lustre
LYaPAS
Lynx
P
P
P4
P′′
ParaSail (programming language)
PARI/GP
Pascal – ISO 7185
Pascal Script
PCASTL
PCF
PEARL
PeopleCode
Perl
PDL
Pharo
PHP
Pico
Picolisp
Pict
Pig (programming tool)
Pike
PILOT
Pipelines
Pizza
PL-11
PL/0
PL/B
PL/C
PL/I – ISO 6160
PL/M
PL/P
PL/SQL
PL360
PLANC
Plankalkül
Planner
PLEX
PLEXIL
Plus
POP-11
POP-2
PostScript
PortablE
POV-Ray SDL
Powerhouse
PowerBuilder – 4GL GUI application generator from Sybase
PowerShell
PPL
Processing
Processing.js
Prograph
PROIV
Prolog
PROMAL
Promela
PROSE modeling language
PROTEL
ProvideX
Pro*C
Pure
Pure Data
PureScript
Python
T
T
TACL
TACPOL
TADS
TAL
Tcl
Tea
TECO
TELCOMP
Tensorflow
TeX
TEX
TIE
TMG, compiler-compiler
Tom
TOM
Toi
Topspeed
TPU
Trac
TTM
T-SQL
Transcript
TTCN
Turing
TUTOR
TXL
TypeScript
Tynker
U
Ubercode
UCSD Pascal
Umple
Unicon
Uniface
UNITY
Unix shell
UnrealScript
V
Vala
Verilog
VHDL
Vim script
Viper
Visual Basic
Visual Basic .NET
Visual DataFlex
Visual DialogScript
Visual Fortran
Visual FoxPro
Visual J++
Visual LISP
Visual Objects
Visual Prolog
VSXu
X
X++
X10
XAML
xBase
xBase++
XBL
XC (targets XMOS architecture)
xHarbour
XL
Xojo
XOTcl
XOD (programming language)
XPL
XPL0
XQuery
XSB
XSharp
XSLT
Xtend
C
C
C– (C minus minus)
C++ (C plus plus) – ISO/IEC 14882
C*
C# (C sharp) – ISO/IEC 23270
C/AL
Caché ObjectScript
C Shell (csh)
Caml
Cayenne
CDuce
Cecil
Cesil
Céu
Ceylon
CFEngine
Cg
Ch
Chicken
Chapel
Charm
CHILL
CHIP-8
chomski
ChucK
Cilk
Citrine
CL (IBM)
Claire
Clarion
Clean
Clipper
CLIPS
CLIST
Clojure
CLU
CMS-2
COBOL – ISO/IEC 1989
CobolScript – COBOL Scripting language
Cobra
CoffeeScript
ColdFusion
COMAL
Combined Programming Language (CPL)
COMIT
Common Intermediate Language (CIL)
Common Lisp (also known as CL)
COMPASS
Component Pascal
Constraint Handling Rules (CHR)
COMTRAN
Cool
Coq
Coral 66
CorVision
COWSEL
CPL
Cryptol
Crystal
Csound
CSS
Cuneiform
Curl
Curry
Cybil
Cyclone
Cypher Query Language
Cython
CEEMAC
CEEMAC
G
Game Maker Language(Scripting language)
GameMonkey Script
GAMS
GAP
G-code
GDScript
Genie
GDL
GEORGE
GLSL
GNU E
GNU Guile
Go
Go!
GOAL
Gödel
Golo
GOM (Good Old Mad)
Google Apps Script
Gosu
GOTRAN
GPSS
GraphTalk
GRASS
Grasshopper
Groovy
O
o:XML
Oak
Oberon
OBJ2
Object Lisp
ObjectLOGO
Object REXX
Object Pascal
Objective-C
Objective-J
Obliq
OCaml
occam
occam-π
Octave
OmniMark
Opa
Opal
OpenCL
OpenEdge ABL
OPL
OpenVera
OPS5
OptimJ
Orc
ORCA/Modula-2
Oriel
Orwell
Oxygene
Oz

M
M2001
M4
M#
Machine code
MAD (Michigan Algorithm Decoder)
MAD/I
Magik
Magma
Máni
Maple
MAPPER (now part of BIS)
MARK-IV (now VISION:BUILDER)
Mary
MATLAB
MASM Microsoft Assembly x86
MATH-MATIC
Maude system
Maxima (see also Macsyma)
Max (Max Msp – Graphical Programming Environment)
MaxScript internal language 3D Studio Max
Maya (MEL)
MDL
Mercury
Mesa
Metafont
MHEG-5 (Interactive TV programming language)
Microcode
MicroScript
MIIS
Milk (programming language)
MIMIC
Mirah
Miranda
MIVA Script
ML
Model 204
Modelica
Modula
Modula-2
Modula-3
Mohol
MOO
Mortran
Mouse
MPD
Mathcad
MSL
MUMPS
MuPAD
Mutan
Mystic Programming Language (MPL)
Q
Q (programming language from Kx Systems)
Q# (Microsoft programming language)
Qalb
Quantum Computation Language
QtScript
QuakeC
QPL
Qbasic
.QL
R
R
R++
Racket
Raku
RAPID
Rapira
Ratfiv
Ratfor
rc
Reason
REBOL
Red
Redcode
REFAL
REXX
Rittle
Rlab
ROOP
RPG
RPL
RSL
RTL/2
Ruby
Rust
W
WATFIV, WATFOR
WebAssembly
WebDNA
Whiley
Winbatch
Wolfram Language
Wyvern

Y
YAML
Yorick
YQL
Yoix
YUI
D
D
DAML
Dart
Darwin
DataFlex
Datalog
DATATRIEVE
dBase
dc
DCL
DinkC
DIBOL
Dog
Draco
DRAKON
Dylan
DYNAMO
DAX (Data Analysis Expressions)
E
E
Ease
Easy PL/I
EASYTRIEVE PLUS
eC
ECMAScript
Edinburgh IMP
EGL
Eiffel
ELAN
Elixir
Elm
Emacs Lisp
Emerald
Epigram
EPL (Easy Programming Language)
EPL (Eltron Programming Language)
Erlang
es
Escher
ESPOL
Esterel
Etoys
Euclid
Euler
Euphoria
EusLisp Robot Programming Language
CMS EXEC (EXEC)
EXEC 2
Executable UML
Ezhil
F
F
F#
F*
Factor
Fantom
FAUST
FFP
fish
Fjölnir
FL
Flavors
Flex
FlooP
FLOW-MATIC
FOCAL
FOCUS
FOIL
FORMAC
@Formula
Forth
Fortran – ISO/IEC 1539
Fortress
FP
Franz Lisp
Futhark
F-Script
H
Hack
HAGGIS
HAL/S
Halide (programming language)
Hamilton C shell
Harbour
Hartmann pipelines
Haskell
Haxe
Hermes
High Level Assembly
HLSL
Hollywood
HolyC
Hop
Hopscotch
Hope
Hugo
Hume
HyperTalk
I
Io
Icon
IBM Basic assembly language
IBM HAScript
IBM Informix-4GL
IBM RPG
IDL
Idris
Inform
J
J
J#
J++
JADE
JAL
Janus (concurrent constraint programming language)
Janus (time-reversible computing programming language)
JASS
Java
JavaFX Script
JavaScript(Scripting language)
Jess (programming language)
JCL
JEAN
Join Java
JOSS
Joule
JOVIAL
Joy
JQuery
JScript
JScript .NET
Julia
Jython
N
NASM
Napier88
Neko
Nemerle
NESL
Net.Data
NetLogo
NetRexx
NewLISP
NEWP
Newspeak
NewtonScript
Nial
Nice
Nickle (NITIN)
Nim
NPL
Not eXactly C (NXC)
Not Quite C (NQC)
NSIS
Nu
NWScript
NXT-G
S
S
S2
S3
S-Lang
S-PLUS
SA-C
SabreTalk
SAIL
SAM76
SAS
SASL
Sather
Sawzall
Scala
Scheme
Scilab
Scratch
Script.NET
Sed
Seed7
Self
SenseTalk
SequenceL
Serpent
SETL
SIMPOL
SIGNAL
SiMPLE
SIMSCRIPT
Simula
Simulink
Singularity
SISAL
SLIP
SMALL
Smalltalk
SML
Strongtalk
Snap!
SNOBOL (SPITBOL)
Snowball
SOL
Solidity
SOPHAEROS
Source
SPARK
Speakeasy
Speedcode
SPIN
SP/k
SPS
SQL
SQR
Squeak
Squirrel
SR
S/SL
Starlogo
Strand
Stata
Stateflow
Subtext
SBL
SuperCollider
SuperTalk
Swift (Apple programming language)
Swift (parallel scripting language)
SYMPL
SystemVerilog
Z
Z notation
Zebra, ZPL, ZPL2
Zeno
ZetaLisp
ZOPL
Zsh
ZPL
Z++