STACK.peek函数，遇到麻烦，C ++

Question

CARD& STACK::peek()
{
    if(cards.size == 0)
    {
        CARD temp = CARD {-1, -1};
        return temp;
    }
    return cards.back();
}

This is the function I am having trouble with.

• CARD is just a struct with two int variables, called rank and suit .

• STACK is a class that manages an std::vector<CARD> , that is called cards .

The function is supposed to return a reference to the card on top of the stack, or return the reference to a dummy card if the vector is empty.

First of all, I get a warning that says a reference to a local variable temp is returned. What is wrong with that? How will that effect the function? What do I do about it?

Second, I am trying to use this function with another function I created called cardToString

char* cardToString(CARD& c);

It is supposed to use the rank and suit variables in the passed CARD to look up string values in a table, concatenate the two strings together, and return a pointer to the new string.

So the end result looks like:

cout<<cardToString(deck.peek())<<"\n";

but this line of code will execute up to the cardToString function, then just stop for some reason. It is annoying the hell out of me because it just stops, there is no error message and there does not look like there is anything wrong to me.

Can somebody help me out?

Edit: here is the cardToString function

char *cardToString(const CARD& c)
{
    if(c.r >= 13 || c.r < 0 || c.s >= 4 || c.s < 0)
    {
        std::cout<<"returned null";
        return NULL;
    }

    char *buffer = new char[32];

    strcpy(buffer, RANKS[c.r]);
    strcat(buffer, " of ");
    return strcat(buffer, SUITS[c.s]);
}

I specifically want the function STACK.peek() to return the address of the CARD that already exists on the top of the STACK . It seems to make more sense to do that than to create a copy of the card that I want to return.

Answer 1

First of all, I get a warning that says a reference to a local variable temp is returned. What is wrong with that? How will that effect the function? What do i do about it?

A local variable, as it name implies, is local to the function it belongs to, so it's destroyed as the function returns; if you try to return a reference to it, you'll return a reference to something that will cease to exist at the very moment the function returns.

Although in some cases this may seem to work anyway, you're just being lucky because the stack hasn't been overwritten, just call some other function and you'll notice it will stop working.

You have two choices: first of all, you can return the CARD by value instead of reference; this, however, has the drawback of not allowing the caller to use the reference to modify the CARD as is stored in the vector (this may or may not be desirable).

Another approach is to have a static dummy CARD instance stored in the STACK class, that won't have these lifetime problems, and that can be returned when you don't have elements in the vector ; however, you should find a method to "protect" its field, otherwise a "stupid" caller may change the values of your "singleton" dummy element, screwing up the logic of the class. A possibility is to change CARD in a class that will encapsulate its fields, and will deny write access to them if it's the dummy element.

As for the cardToString function, you're probably doing something wrong with the strings (and I'm almost sure you're trying to return a local also in this case), but without seeing the body of the function it's difficult to tell what.

By the way, to avoid many problems with strings I suggest you to use, instead of char * , the std::string class, which takes away most of the ugliness and of the low level memory management of the usual char * .

Also, I'd suggest you to change cardToString to take a const reference, because most probably it doesn't need to change the object passed as reference, and it's good practice to clearly mark this fact (the compiler will warn you if you try to change such reference).

---

Edit The cardToString function should be working fine, as long as the RANKS and SUITS arrays are ok. But , if you used that function like you wrote, you're leaking memory, since for each call to cardToString you make an allocation with new that is never freed with delete ; thus, you are losing 32 bytes of memory per call.

As stated before, my tip is to just use std::string and forget about these problems; your function becomes as simple as this:

std::string cardToString(const CARD& c)
{
    if(c.r >= 13 || c.r < 0 || c.s >= 4 || c.s < 0)
        return "(invalid card)";

    return std::string(RANKS[c.r]) + " of " + SUITS[c.s];
}

And you don't need to worry about memory leaks and memory allocations anymore.

---

For the reference/value thing: if the caller do not need to use the reference to modify the object stored in the vector, I strongly suggest passing it by value. The performance hit is negligible: two int s instead of one pointer means 8 vs 4 bytes on most 32 bit architectures, and 8 bytes vs 8 bytes on most 64 bit machines (and also accessing the fields via pointer has a small cost).

This kind of micro-optimization should be the last of your concerns. Your top priority is to write correct and working code, and the last thing you should do is to let micro-optimization get in the way of this aim.

Then, if you experience performance problems, you'll profile your application to find where the bottlenecks are and optimize those critical points.

Answer 2

You cannot return a reference to a local variable, because the local variable no longer exists when the function returns.

You need to return by-value, not by-reference (ie CARD STACK::peek() { ... } ).