C++ – Is it possible to pass a brace-enclosed initializer as a macro parameter

cc-preprocessorc++11language-lawyer

I have a function that I call like this:

literal<long[2]>({1, 2});

I want to write a macro that expands to this statement, e.g.:

MYMACRO(long[2], {1, 2})

Unfortunately, the preprocessor is not aware of brace-matching so it sees three arguments (the second and third are {1 and 2}, respectively).

This is a known limitation of the preprocessor, and the simplest solution is often to add extra parentheses, if possible, in the macro invocation.

But, in this case, placing the brace-enclosed initializer inside parentheses appears to change its meaning:

literal<long[2]>(({1, 2}));

(g++ 4.8) error: left operand of comma operator has no effect [-Werror=unused-value]

Is this a GCC bug or correct by design? Is there any way to accomplish what I want?

Update

I probably should have been more clear in the phrasing of the original questions. The preprocessor hasn't changed in forever (even variadic macros have been a GCC extension for a long time). The practical workarounds in this case are useful, but they're also very well known and not to the point I want to get at.

I really want to know whether anything was added to C++11 to specifically address this issue (or was it an oversight?). The quirky handling of braces in macro invocations seems like a much bigger issue now, given the greatly expanded use of brace-enclosed lists throughout the language.

I'm especially annoyed by the fact that putting parentheses around a brace-enclosed initializer list changes the way it's parsed when used as a function parameter. Is there any other parameter to a function invocation that cannot be parenthesized? It seems like special-case hell when writing macros that pass parameters to functions.

I'm really hoping somebody can point out that this is a GCC bug, or explain why putting parentheses around a brace-enclosed initializer list must change its meaning.

Best Answer

You can use __VA_ARGS__:

#define MYMACRO(T,...) literal<T>(__VA_ARGS__);

In case you have more parameters, you can use an indirection:

#define UNWRAP(...) __VA_ARGS__
#define MYMACRO(T,A) literal<T>(UNWRAP A);

and now you can use

MYMACRO( long[2], ({1, 2}) )

Updated answer

You could also, if you like, replace the curly brackets in the invocation of the macro with the round brackets:

#define BRACED_INIT_LIST(...) {__VA_ARGS__}
#define MYMACRO(T,A) literal<T>(BRACED_INIT_LIST A);

and call

MYMACRO( long[2], (1, 2) )

which is IMHO consistent with typical macro-invocation-styles.

Some words on your other questions: The preprocessor knows nothing about the language (C, C++, C++11) and hence should not care about the special meaning of symbols. It is tracking round brackets, but almost everything else is just tokens.

I also think it's not an oversight from the standard committee as the focus should be on making the use of the preprocessor superfluous for most cases. Have you considered other (non-macro) techniques to implement MYMACRO? Also, work-arounds for the remaining use-cases (as shown above) are certainly possible.

Finally, it is certainly not a bug in GCC as the compiler simply implements what the standard says.

Related Solutions

C++ – When to use the brace-enclosed initializer

I think the following could be a good guideline:

If the (single) value you are initializing with is intended to be the exact value of the object, use copy (=) initialization (because then in case of error, you'll never accidentally invoke an explicit constructor, which generally interprets the provided value differently). In places where copy initialization is not available, see if brace initialization has the correct semantics, and if so, use that; otherwise use parenthesis initialization (if that is also not available, you're out of luck anyway).
If the values you are initializing with are a list of values to be stored in the object (like the elements of a vector/array, or real/imaginary part of a complex number), use curly braces initialization if available.
If the values you are initializing with are not values to be stored, but describe the intended value/state of the object, use parentheses. Examples are the size argument of a vector or the file name argument of an fstream.

Jquery – Send to and get value from a MVC3 controller by AJAX

Button click event

$(document).ready(function ()
{
    $('#ButtonName').click(function ()
    {
        if ($('#YourHtmlTextBox').val() != '')
        {
            sendValueToController();
        }
        return false;
    });
});

You call your ajax function like so:

function sendValueToController()
{
    var yourValue = $('#YourHtmlTextBox').val();

    $.ajax({
        url: "/ControllerName/ActionName/",
        data: { YourValue: yourValue },
        cache: false,
        type: "GET",
        timeout: 10000,
        dataType: "json",
        success: function (result)
        {
            if (result.Success)
            { // this sets the value from the response
                $('#SomeOtherHtmlTextBox').val(result.Result);
            } else
            {
                $('#SomeOtherHtmlTextBox').val("Failed");
            }
        }
    });
}

This is the action that is being called

public JsonResult ActionName(string YourValue)
{
    ...
    return Json(new { Success = true, Result = "Some Value" }, JsonRequestBehavior.AllowGet);
}

Update

Best Answer

Related Solutions

C++ – When to use the brace-enclosed initializer

Jquery – Send to and get value from a MVC3 controller by AJAX

Related Topic