#!/usr/bin/perl -w
use strict;

my $eq = <STDIN>;
print eval $eq, "\n";
[download]

Thanks! That's awesome. I don't need all those little variables and perl eval()s for me! Great! -Variable_B

Glad you liked it. As we all know, Laziness is a wonderful virtue. But I figured I should provide you with something more constructive. Here are the basics of that reverse Polish calculator I was rambling about. It supports +, -, *, /. Print the stack with 'p' and quit with 'q'. You could probably make this a bit more concise if you wanted to. In fact, that might make for some pretty good GOLF. Anyway, Enjoy.

#!/usr/bin/perl -w
use strict;

my @stack = ();
my %ops = ( '+' => \&sum, '-' => \&difference,
            '*' => \&product, '/' => \&quotient,
            'p' => sub { print $_, "\n" foreach @stack; },
            'q' => sub { exit 0; }
          );

while(<>) {
  chomp;
  if (exists $ops{$_}) {
    $ops{$_}->();
  # The badass regex is out of the Perl Cookbook, page 44
  # Makes sure non-ops are valid numbers
  } elsif ($_ =~ /^([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/) {
    push @stack, $_;
  } else {
    warn "Bad input: $_\n";
  }
}

sub pop_stack {
  my $rhs = pop @stack;
  my $lhs = pop @stack;
  if ((! defined $lhs) || (! defined $rhs)) {
    warn "Not enough values on stack!\n";
    push @stack, $rhs if defined $rhs;
    return undef;
  }
  return $lhs, $rhs;
}

sub sum {
  my ($lhs, $rhs) = pop_stack;
  return unless defined $lhs;
  my $res = $lhs + $rhs;
  print "$res \n";
  push @stack, $res;
}

sub difference {
  my ($lhs, $rhs) = pop_stack;
  return unless defined $lhs;
  my $res = $lhs - $rhs;
  print "$res \n";
  push @stack, $res;
}

sub product {
  my ($lhs, $rhs) = pop_stack;
  return unless defined $lhs;
  my $res = $lhs * $rhs;
  print "$res \n";
  push @stack, $res;
}

sub quotient {
  my ($lhs, $rhs) = pop_stack;
  return unless defined $lhs;
  my $res = $lhs / $rhs;
  print "$res \n";
  push @stack, $res;
}
[download]

You have to be cautious of using eval(). It's quite possible for some joker to come along and type "rm / -rf" and run your program. That said, it's also the easiest way to get the code to work. Some others have suggested some very good checks to take care of malicious use of eval().



If you make something idiot-proof, eventually someone will make a better idiot.
I am that better idiot.

chomp($operator = <STDIN>);
[download]

print $a + $b, "\n";
[download]

First off, you can't have your <STDIN> in double-quotes. That will, quite literally, assign the characters

<STDIN>

What you can do is use a conditional statement to check for the operator that the user puts in. Something generic like the following will work. Of course, you'll have to work out the mojo behind each condition.

#!/usr/bin/perl -w

print "First Number: ";
$a = <>;     # <> is short for <STDIN>

print "Second Number: ";
$b = <>;

print "Operator: ";
$operator = <>;

if ( $operator == "+" ) {
   # Do some addition
} elsif ( $operator == "-" ) {
   # Do some subtraction
} elsif ( $operator == "/" ) {
   # Division
} elsif { $operator == "*" ) {
   # Multiply
} else {
   # Catch everything else
   print "DON'T YOU KNOW MATH?!?!\nMONKIES CAN DO MATH!!!\n";
}
[download]

And there you have it. CS 101, Assignment 1.

$operator = <STDIN>;
chomp $operator;
if ($operator eq '+')
{
   $result = $a + $b;
}
elsif ($operator eq '-')
{
   $result = $a - $b;
}
elsif ($operator eq '*')
{
   $result = $a * $b;
}
else
{
   die "unknown operator \"$operator\"\n";
}
[download]

$first=<STDIN>;
$second=<STDIN>;
$operator=<STDIN>;
chomp $first;
chomp $second;
chomp $operator;

$expression = "$first $operator $second";
print "$expression:\n";

$result = eval $expression;
if ($@)  # ($@ is set by eval if something went wrong)
{
    print "oh no!: $@\n";
}
else
{
    print "$result\n";
}
[download]

By the way, you shouldn't get into the habit of using $a and $b as variable names, since those two variables have special meaning for perl's sort function.

another way you could implement this is using a hash of subroutine references, like so:

use strict;
my $operator=<STDIN>;
my $op_map={};
my $one=10;
my $two=5;
chomp $operator;
define_op_map();
if ( defined ($op_map->{$operator}) ) {
  &{$op_map->{$operator}};
  } else {
  print "This op is undefined. Executing it might end the universe as 
+we know it.\n";
  }

sub define_op_map {
  $op_map->{'+'}=sub{print $one + $two . "\n"};
  $op_map->{'-'}=sub{print $one - $two . "\n"};
  $op_map->{'*'}=sub{print $one * $two . "\n"};
  $op_map->{'/'}=sub{print $one / $two . "\n"};
  }
[download]

$op_map->{'camel'}=sub{print "$one is a $two with humps.\n"};
[download]

CU
Robartes-

A Calculator might be a bad task as "one of your first programs", because parsing mathematical expressions is an advanced challenge, but you can do it in steps, getting better and better. First idea is getting operand,operator,operand as single unput:

chomp(my $left = <STDIN>);
chomp(my $op = <STDIN>);
chomp(my $right = <STDIN>);

print $op eq '+' ? $left + $right :
      $op eq '-' ? $left - $right :
      $op eq '*' ? $left * $right :
      $op eq '/' ? $left / ($right||1) :
      "dunno operator '$op'",
, "\n";
[download]

Next step is to read the whole thing in a one string:

chomp( my $expr = <STDIN> );
# and to parse it with simple split
my ($left,$op,$right) = split /\s+/,$expr
# next step is code of above
[download]

Sooner or later you'll want to replace the ?:?: .. chain with a hash:

my %operations = (
  '+' => sub { (shift) + (shift) },
  '-' => sub { (shift) - (shift) },
  '*' => sub { (shift) * (shift) },
  '/' => sub { (shift) / (shift||1) },
);

my ($left,$op,$right) = ...; #wherever you get them from
print exists $operations{$op} ?
    $operations{$op}->($left,$right) :
    "dunno operator '$op'",
"\n";
[download]

Next you want to verify the input using a regexp:

chomp(my $expr = <STDIN>);
$expr =~ /(\d+)\s+([+-/*])\s+(\d+)/ or
   die "invalid input\n";
my ($left,$op,$right) = ($1,$2,$3);
# ...
[download]

Then you'll find advanced regexps for numbers (see perlfaq4), Math::Expr, and finally Parse::RecDescent .