Geek asks and answers

Assigning temp to const ref causes a segmentation error

better illustrated by example:

tok.h

#include <string>

static const char* defaultDelim = ".,;";

class Tokenizer {
public:
    Tokenizer():
        // 'delim' is the const ref member that is initialized by the temp string 
        delim( (altDelim.size())? altDelim : std::string(defaultDelim) ) 
    {}

    size_t scan(const std::string& str)
    { return str.find_first_of(delim); }

    static void setDelim(const std::string& d) { altDelim = d; }
private:
    static std::string altDelim;
    const std::string& delim;
};

main.cpp

#include <iostream>
using namespace std;

#include "tok.h"

std::string Tokenizer::altDelim;

int main()
{
    Tokenizer tok;

    size_t pos = tok.scan("hello, world");
    cout << pos << endl;
}

the program prints 0, which is incorrect. Real code gets seg error.

I would expect that here the rule of extending the life of the pace assigned to the const link will be respected, but apparently this is not so. Do you know the reason?

+5
source share
1 answer

This rule does not apply to class members. This is specified in 12.2.5 of the C ++ 03 standard:

A temporary bound to a reference member in a constructor ctor-initializer
persists until the constructor exits.

, , , . , , , .

// header file
struct A {
  A();
  B &b;
};


// file1.cpp
void f()
{
  A a; // Reserve the size of a single reference on the stack.
}


// file2.cpp
A::A()
: b(B()) // b is referencing a temporary, but where do we keep it?
         // can't keep the temporary on the stack because the
         // constructor will return and pop everything off the stack.
         // Can't keep it in the class because we've already said the
         // class just contains a single reference.
{
}
+4

More articles:


All Articles