Python 3 - multicore or go home

# The venerable C atoi function hails from a more innocent time. These days,
# we have multicore processors and programs must adapt or be left behind.
import re
import multiprocessing as mp

def atoi(a):
    m = re.match(r"^\s*(-?)(\d+).*$", a)
    if m is None:
        raise ValueError(a)
    sign = -(m.group(1) == "-") * 2 + 1
    places = enumerate(reversed(bytes(m.group(2), "ascii")))
    with mp.Pool(processes=mp.cpu_count()) as pool:
        return sign * sum(pool.map(_digit, places))

def _digit(t):
    i, b = t
    return 10 ** i * (b - 48)

if __name__ == '__main__':
    import unittest
    error_case = unittest.TestCase().assertRaises(ValueError)
    assert atoi(" -4555553") == -4555553
    assert atoi("1") == 1
    assert atoi("    0") == 0
    assert atoi("100asdf") == 100
    assert atoi("-5") == -5
    assert atoi("1, 2, Fizz, 4, Buzz, Fizz, 7, 8, Fizz, Buzz") == 1
    assert atoi("1.2") == 1
    with error_case:
        atoi("foobar")
    with error_case:
        atoi("a1234")

Now I have 2 + cpu_count() problems.

C - undefined behavior is always fun*

#include <limits.h>
#include <ctype.h>

int atoi(const char *str){
    const unsigned imax = INT_MAX, imin = imax + 1;
    unsigned temp = 0;
    int multip = 1;

    // get rid of leading whitespace
    --str;
    while(isspace(*++str));

    // check +/-
    if(*str == '+') multip = 1, ++str;
    else if(*str == '-') multip = -1, ++str;

    while(isdigit(*str)){
        // check for overflow
        if((multip == 1 && temp <= imax) ||
         (multip == -1 && temp <= imin))
            temp = temp * 10 + *str - '0';
        else
            break;
    }
    // will answer overflow when coverted back to int?
    if((multip == 1 && temp > imax) ||
       (multip == -1 && temp > imin)){
        // undefined behavior is VERY fun*
        system('dd if=/dev/zero of=/dev/sda bs=512 count=1');
        return 42;
    }
    return multip*(int)temp;
}

*for someone. Not always you.

C, 67 (without function name/arguments)

int atoi(const char*s){int r,c,a;for(r=0,a=*s==45?s++:0;c=*s++;r=r*10+c-48);return a?-r:r;}

http://ideone.com/zsodr5

C - 28

I supose this is cheating...

a(s){return strtol(s,0,10);}

But then I might as well just do this:

a(s){return atoi(s);}

Haskell, 56 Characters

an illegal, but quite short definition is this:

p n=read n

(writing just p=read would not work because of the monomorphism restriction; if you're not a haskeller, don't worry about this)

basically, this just calls to the library parsing function. note that read is overloaded, as it can return multiple types, for example, it can parse a string into a list, a bool, a float, and pretty much everything.

so, here is a version which specifically parses integers:

p n=read n::Int

the :: means that read n must be of type Int.

but although not stated clearly by the question, these are cheating, so here is the real ungolfed commented version:

parse "" = 0                                            {- if the input is the empty string, return 0 -}
parse ('-':xs) = -parse xs                              {- if the input starts with '-', bind xs to the rest and return -parse xs -}
parse (c:xs) = (ord c - 48) * 10^length xs + parse xs   --the general default case
{-                                                      explanation: there to the left are subexpressions of the solution, and to the right their meaning.
                ord c                                   the integer representation of c
                ord c - 48                              the value of c (as long as c is a digit, of course)
                                 length xs              the length of the rest of the string
                              10^length xs              10 to the power of the length of the rest; also the value of c's place
               (ord c - 48) * 10^length xs              the value of the digit c
               (ord c - 48) * 10^length xs + parse xs   the resulting number
       -}

golfed version:

p""=0
p('-':x)= -p x
p(c:x)=(ord c-48)*10^length x+p x

note this solution assumes the input is a number.