[C++] Reference-initialisatie d.m.v. conditional operator

[Verwijderd]

Afgesplitst van De Devschuur Coffee Corner - Iteratie 3

Is de ?: operator echt de enige manier om conditioneel een reference te initialiseren?

C++:

int& foo;

if ( boolean )
  foo = bar;
else
  foo = baz;

Werkt niet omdat: een reference dient altijd geïnitialiseerd te zijn.

Wat dacht je dan van

C++:

if ( boolean )
  int& foo = bar;
else
  int& foo = baz;

Nee, dat werkt ook niet. Want na de if raakt foo uit scope..

Mag ik u voorstellen aan deze oude vriend?

C++:

if ( boolean )
  goto next;

  int& foo = baz;
  goto finish;

next:
  int& foo = bar;

finish:

Foo already initialized. Je meent het?

Dan maar zo:

C++:

int& foo = boolean ? bar : baz;

al is dat bij ingewikkeldere constructs natuurlijk totaal onleesbaar.

[ Voor 5% gewijzigd door Woy op 13-05-2013 11:06 ]

[.oisyn]

Verwijderd schreef op zaterdag 11 mei 2013 @ 23:36:
Is de ?: operator echt de enige manier om conditioneel een reference te initialiseren?

Sterker nog, dat is de reden dat hij bestaat. Niet specifiek voor references, maar wel initialization van objects waar een expression vereist is.

Imho schiet C++ daar wel wat te kort. Probeer maar eens een value te constructen waarvan de gewenste ctor overload afhangt van een expressie.

[PrisonerOfPain]

Verwijderd schreef op zaterdag 11 mei 2013 @ 23:36:

al is dat bij ingewikkeldere constructs natuurlijk totaal onleesbaar.

Je zou nog een init_ref<T> functie kunnen maken die 't doet, maar dat is ook niet heel anders dan een ?:-constructie. Gewoon netjes opschrijven;

C++:

T &ref = lijpe_conditional
    ? expression_1
    : expression_2;

[Daos]

Of gewoon met pointers werken:

C++:

int* foo; 

if ( boolean ) 
  foo = &bar; 
else 
  foo = &baz;

als je de waarde nodig hebt gebruik je *foo.

[PrisonerOfPain]

Daos schreef op zondag 12 mei 2013 @ 12:32:
Of gewoon met pointers werken:

C++:

int* foo; 

if ( boolean ) 
  foo = &bar; 
else 
  foo = &baz;

als je de waarde nodig hebt gebruik je *foo.

Dat wil je niet altijd

[Verwijderd]

Het zal, i guess, over het algemeen wel naar dezelfde code compileren.

[Daos]

Verwijderd schreef op zondag 12 mei 2013 @ 18:22:
Het zal, i guess, over het algemeen wel naar dezelfde code compileren.

Daar lijkt het wel op (refptr.cpp):

C++:

#include <iostream>

int test_ref(bool boolean) {
    int bar = 5;
    int baz = 10;

    int& foo = boolean ? bar : baz;
    
    return foo;
}

int test_ptr(bool boolean) {
    int bar = 5;
    int baz = 10;

    int* foo = boolean ? &bar : &baz;
    
    return *foo;
}

int main(void) {
    std::cout << test_ref(true) << std::endl;
    std::cout << test_ref(false) << std::endl;
    std::cout << test_ptr(true) << std::endl;
    std::cout << test_ptr(false) << std::endl;
}

Assembly van de twee functies is identiek (g++ refptr.cpp -S):

code:

.globl __Z8test_refb
    .def    __Z8test_refb;  .scl    2;  .type   32; .endef
__Z8test_refb:
LFB963:
    pushl   %ebp
LCFI0:
    movl    %esp, %ebp
LCFI1:
    subl    $20, %esp
LCFI2:
    movl    8(%ebp), %eax
    movb    %al, -20(%ebp)
    movl    $5, -8(%ebp)
    movl    $10, -12(%ebp)
    cmpb    $0, -20(%ebp)
    je  L2
    leal    -8(%ebp), %eax
    jmp L3
L2:
    leal    -12(%ebp), %eax
L3:
    movl    %eax, -4(%ebp)
    movl    -4(%ebp), %eax
    movl    (%eax), %eax
    leave
LCFI3:
    ret
LFE963:
.globl __Z8test_ptrb
    .def    __Z8test_ptrb;  .scl    2;  .type   32; .endef
__Z8test_ptrb:
LFB964:
    pushl   %ebp
LCFI4:
    movl    %esp, %ebp
LCFI5:
    subl    $20, %esp
LCFI6:
    movl    8(%ebp), %eax
    movb    %al, -20(%ebp)
    movl    $5, -8(%ebp)
    movl    $10, -12(%ebp)
    cmpb    $0, -20(%ebp)
    je  L5
    leal    -8(%ebp), %eax
    jmp L6
L5:
    leal    -12(%ebp), %eax
L6:
    movl    %eax, -4(%ebp)
    movl    -4(%ebp), %eax
    movl    (%eax), %eax
    leave
LCFI7:
    ret

[Grijze Vos]

Verwijderd schreef op zaterdag 11 mei 2013 @ 23:36:
Werkt niet omdat: een reference dient altijd geïnitialiseerd te zijn.

Kun je hem niet op null initialiseren?

[Verwijderd]

Grijze Vos schreef op maandag 13 mei 2013 @ 10:15:
[...]

Kun je hem niet op null initialiseren?

Je kan een reference niet naar een NULL object laten wijzen (ja, met pointer magic). Maar daar schiet je alsnog niets mee op, want je kan een reference niet re-assignen.

[Grijze Vos]

Verwijderd schreef op maandag 13 mei 2013 @ 10:24:
[...]

Je kan een reference niet naar een NULL object laten wijzen (ja, met pointer magic). Maar daar schiet je alsnog niets mee op, want je kan een reference niet re-assignen.

Hmm, ik zie maar weer dat mijn kennis van C++ heel beperkt is. Ik wist niet dat een reference niet ge-re-seat kon worden.

[Caelorum]

Grijze Vos schreef op maandag 13 mei 2013 @ 10:37:
[...] Hmm, ik zie maar weer dat mijn kennis van C++ heel beperkt is. Ik wist niet dat een reference niet ge-re-seat kon worden.

Een reference is (correct me if I'm wrong) gewoon een alias. Een andere naam voor hetzelfde object. Kan me ook goed voorstellen dat de compiler het een en ander gewoon weggooit, omdat een verwijzing naar de reference eigenlijk een verwijzing naar het object dat gereferenced wordt is.

[.oisyn]

Caelorum schreef op maandag 13 mei 2013 @ 10:44:
[...]

Een reference is (correct me if I'm wrong) gewoon een alias. Een andere naam voor hetzelfde object. Kan me ook goed voorstellen dat de compiler het een en ander gewoon weggooit, omdat een verwijzing naar de reference eigenlijk een verwijzing naar het object dat gereferenced wordt is.

Een reference is gewoon een const pointer (niet te verwarren met pointer-naar-const) met ietwat andere syntax, meer niet.

[epic007]

Daos schreef op zondag 12 mei 2013 @ 12:32:
Of gewoon met pointers werken:

C++:

int* foo; 

if ( boolean ) 
  foo = &bar; 
else 
  foo = &baz;

als je de waarde nodig hebt gebruik je *foo.

C++:

int& give_me_an_int_ref(bool boolean)
{
  int* pfoo; 

  if ( boolean ) 
    pfoo = &bar; 
  else 
    pfoo = &baz;

  return *pfoo;
}

int& foo =  give_me_an_int_ref(boolean);

[Verwijderd]

Dat is ook weer scope vervuiling

Ik bedenk met overigens net dat het ook met een lambda functie kan:

C++:

int &foo = [&,bar,baz,boolean](){
  if ( boolean ) 
    return bar; 
  else 
    return baz; 
}();

(untested)

Wat waarschijnlijk de netste manier is voor wat ingewikkeldere constructies.

[Caelorum]

.oisyn schreef op maandag 13 mei 2013 @ 11:06:
[...] Een reference is gewoon een const pointer (niet te verwarren met pointer-naar-const) met ietwat andere syntax, meer niet.

en een const reference is dan een const-pointer-naar-const?

@onder: ah ik zie het al: http://www.parashift.com/c++-faq-lite/const-ref-alt.html

const X& x and X const& x are equivalent. The real question is which should be used.

[ Voor 24% gewijzigd door Caelorum op 14-05-2013 13:33 ]

[.oisyn]

Als je bedoelt een reference-naar-const, dan ja. Const references (int & const i) bestaan niet (of ze zijn impliciet const)

[ Voor 10% gewijzigd door .oisyn op 14-05-2013 12:46 ]

[Zoijar]

Vraag is hoe vaak je dit nodig hebt. Meestal zal het toch een functie zijn die dan beslists welke je gebruikt; zeker als het een ingewikkelde conditional is. En daar kan je gewoon returnen, net als bij het lambda voorbeeld.

?operator is overigens ook de enige manier om bijvoorbeeld een constexpr met een conditional te hebben (constexpr int max(int a, int b) {return a < b ? b : a;})

[MSalters]

Niet helemaal waar: constexpr int max(int a, int b) {return a + int(b>a) * (b-a); }