Very Computer

Given a function like
    void f(char *);
we all know we can make the call
    f("ab");
Now, since "ab" is equivalent to the static
structure {'a','b','\0'}, I claim we would
also be able to call the function like
    f({'a','b','\0'});
My compiler (MSVC++4.2, btw) does not agree.
What do you say?
--
Martin Fabian
-----------------------------------------------------------

     tel: +46 (0)31 772 37 16        | Chalmers University of Technology
     fax: +46 (0)31 772 37 30        |       S-412 96 Gothenburg
                                     |              Sweden
Homepage: http://www.control.chalmers.se/~fabian
------------------------------------------------------------------------
Everyone is talking about real-time, but how real is time, really?
---
[ comp.std.c++ is moderated.  To submit articles: try just posting with      ]

[ FAQ:      http://reality.sgi.com/employees/austern_mti/std-c++/faq.html    ]
[ Policy:   http://reality.sgi.com/employees/austern_mti/std-c++/policy.html ]

I believe the problem is that, as you point out, {'a','b','\0'} is not
equivalent to "ab". "ab" is constant expression and {'a', 'b', '\0'} is
an initializer list. Thus I think this would work:

Given f(char* foostring) these two should be (approximately) equivalent:

f("ab")

f(char* barstring = {'a', 'b', '\0'}

I may be wrong, though. I am certain, however, that {'a','b','\0'} is
not equivalent to "ab". I started learning C++ less than a year ago, so
I am far from an expert.

Peder Holdgaard Pedersen
Student of Computer Science at The University of Copenhagen

Jean-Louis Leroy
http://ourworld.compuserve.com/homepages/jl_leroy
---
[ comp.std.c++ is moderated.  To submit articles: try just posting with      ]

[ FAQ:      http://reality.sgi.com/employees/austern_mti/std-c++/faq.html    ]
[ Policy:   http://reality.sgi.com/employees/austern_mti/std-c++/policy.html ]

See if:

  f(static_cast<char*>({'a','b','\0'}))

works.

/Mike
---
[ comp.std.c++ is moderated.  To submit articles: try just posting with      ]

[ FAQ:      http://reality.sgi.com/employees/austern_mti/std-c++/faq.html    ]
[ Policy:   http://reality.sgi.com/employees/austern_mti/std-c++/policy.html ]

"ab" is really the same as {'a','b','\0'} but you could not
take these in a function-
It4s not a expression - it4s an iniatilizer-List!

One chance:
Mr. Stroustrup rewrite the c++-compiler :)

what you could do is that:

#include <stdio.h>

void funcA(char *cp)
{
        printf("cp = %s \n", cp);

Quote:}        

        return 0;

Quote:}

regards,

Otmar

--
****Otmar Schwan  TyBrain Consulting  Heidenheim/Germany ***
*** Web:    www.t-online.de/home/otmar.schwan **********

************************************************************
---
[ comp.std.c++ is moderated.  To submit articles: try just posting with      ]

[ FAQ:      http://reality.sgi.com/employees/austern_mti/std-c++/faq.html    ]
[ Policy:   http://reality.sgi.com/employees/austern_mti/std-c++/policy.html ]

Quote:>Given a function like
>    void f(char *);
>we all know we can make the call
>    f("ab");
>Now, since "ab" is equivalent to the static
>structure {'a','b','\0'}, I claim we would
>also be able to call the function like
>    f({'a','b','\0'});
>My compiler (MSVC++4.2, btw) does not agree.
>What do you say?
>--
>Martin Fabian

Joseph Woodbury

(make cine-bit one word to email me)
---
[ comp.std.c++ is moderated.  To submit articles: try just posting with      ]

[ FAQ:      http://reality.sgi.com/employees/austern_mti/std-c++/faq.html    ]
[ Policy:   http://reality.sgi.com/employees/austern_mti/std-c++/policy.html ]

|>  Given a function like
|>      void f(char *);
|>  we all know we can make the call
|>      f("ab");

No you can't.  The type of f must be "f( char const* )" for this to be
legal.

|>  Now, since "ab" is equivalent to the static
|>  structure {'a','b','\0'}, I claim we would
|>  also be able to call the function like
|>      f({'a','b','\0'});

The {...} syntax is only legal for initializing variables (arrays and
structs), not for passing as an argument.  At least today; there is a
proposal for C9x to allow compound literals of the type:

    f( (char []){ 'a' , 'b' , '\0' } ) ;

Of course, you'd still have to specify the type.  Your {...} list could
be an initializer for a char[3], but just as easily for a struct with
three char elements -- the compiler has no way of knowing.  (Note that
this extension makes it possible in C to obtain the address of a
temporary, and thus introduces C programmers to the lifetime of
temporary issue that we so know and love in C++.  With a different
resolution than C++.)

Anyway, at present, this is only a proposal for the next C standard.
Presumably, if adopted in C, it will rapidly find its way into C++
compilers as an extension, and probably be adopted in the next version
of C++ as well.  For the moment, however, you still have to write:

    char tmp[] = { 'a' , 'b' , '\0' } ;
    f( tmp ) ;

--

GABI Software, 22 rue Jacques-Lemercier, 78000 Versailles, France
        I'm looking for a job -- Je recherche du travail
---
[ comp.std.c++ is moderated.  To submit articles: try just posting with      ]

[ FAQ:      http://reality.sgi.com/employees/austern_mti/std-c++/faq.html    ]
[ Policy:   http://reality.sgi.com/employees/austern_mti/std-c++/policy.html ]