References or pointers?

I have made this example:

#include<iostream>

class Beer {
public:
    Beer() {
        std::cout << "made a beer\n";
        num = 1;
    }

    Beer(int n) : num(n) {}

    int getBeer(){
        return num;
    }

    void remove(){
        num--;
    }

private:
    int num;
};

class Brew {
public:
    /* Simple*/
    void drinkBeer(Beer b) {
        std::cout << "Drank " << b.getBeer() << " instances of beers!\n";
        b.remove();
    }

    void checkBeer(Beer b) {
        std::cout << b.getBeer() << " instances of beers left!\n";
    }

    /* With references. Notice that the '&' is placed AFTER the type like the
     * pointer operator. */
    void drinkBeerRef(Beer& b) {
        std::cout << "Drank " << b.getBeer() << " reference beers!\n";
        b.remove();
    }

    void checkBeerRef(Beer& b) {
        std::cout << b.getBeer() << " reference beers left!\n";
    }

    /* With pointers */
    void drinkBeer(Beer* b) {
        std::cout << "Drank " << b->getBeer() << " pointer beers!\n";
        b->remove();
    }

    void checkBeer(Beer* b) {
        std::cout << b->getBeer() << " pointer beers left!\n";
    }
};

int main(){

    /* (0) Calling default constructor. */
    Beer b1;

    /* (1) Make a brewery where you can drink! checkBeer will not print
     * the right value. */
    Beer b2(10); // make 10 beers.
    Brew brew;
    brew.drinkBeer(b2);
    brew.checkBeer(b2);

    std::cout << std::endl;

    /* (2) Using references */
    Beer b3(10); // make 10 beers.
    brew.drinkBeerRef(b3);
    brew.checkBeerRef(b3);

    std::cout << std::endl;

    /* (3) Using pointers */

    /* Single object containing 10 beers. */
    Beer* b4 = new Beer(10);

    /* or:
     *
     * Beer* b4 = new Beer[10];
     *
     * using default constructor. 10 objects containing 1 beer.
     *
     * */

    brew.drinkBeer(b4);
    brew.checkBeer(b4);

    return 0;
}

How does passing an argument as a reference differ from passing it as a
pointer (besides from also giving the right result)?

When you use 'new' the data is allocated on the heap and when changed in
a function will remain changed after the functions returns. But this is
also the case with references...does 'Beer b3' allocate 'b3' on the heap?