Les parenthèses sont-elles toujours considérées comme un appel de fonction?

Les parenthèses peuvent être utilisées comme opérateur d'appel de fonction, mais ce n'est pas la seule chose pour laquelle elles sont utilisées. Ils sont également utilisés pour le regroupement d'expressions comme dans votre exemple.

Ce que vous recherchez est dans la section 6.5.1 du C standard qui traite des expressions primaires:

Syntaxe

1

x = a * (b+c)-(d*e)

...

5 Une expression entre parenthèses est une expression principale. Son type et sa valeur sont identiques à ceux des expressions sans parenthèse. expression. C'est une lvalue, un désignateur de fonction ou un vide expression si l'expression sans parenthèse est, respectivement, une lvalue, un indicateur de fonction ou une expression vide.

Comme indiqué ci-dessus, les parenthèses peuvent être utilisées pour regrouper des expressions.

L'utilisation comme opérateur d'appel de fonction est détaillée dans la section 6.5.2 sur les expressions Postfix:

postfix-expression:
  ...
  postfix-expression(argument-expression-list opt)
  ...

Donc dans votre expression:

primary-expression:
  identifier
  constant
  string-literal
  ( expression )
  generic-selection

L'utilisation de parenthèses ici correspond à une expression principale mais pas à une expression Postfix.

Aussi , outre le regroupement d'expressions, les parenthèses sont utilisées dans d'autres parties de la grammaire du langage. La section 6.8.4 concernant les instructions de sélection utilise des parenthèses dans la grammaire des instructions if et switch :

• if ( expression ) déclaration
• if ( expression ) instruction else déclaration
• commutateur ( expression ) déclaration

Et la section 6.8.5 concernant les instructions d'itération utilise également des parenthèses dans la grammaire de tandis que et pour les instructions .

• while ( expression ) déclaration
• do instruction while ( expression );
• pour ( expression _opt ; expression_opt ; expression _{opt sub >} ) déclaration
• pour ( déclaration expression_opt ; expression_opt ) déclaration

Un appel de fonction est une expression de suffixe.

Ici, dans ces expressions

    ( *p_func++ )();
    p_func[0]();

sous-expressions (b + c) et (d * e) sont des expressions primaires. Vous pouvez mettre n'importe quelle expression entre parenthèses et vous obtiendrez une expression principale.

Par exemple, vous pouvez même réécrire l'instruction d'expression de la manière suivante

Hello Broman

Dans cette instruction d'expression, il y a les expressions primaires suivantes

#include <stdio.h>

void f( void )
{
    printf( "Hello " );
}

void g( void )
{
    puts( "Broman" );
}    

int main( void )
{
    void ( *funcs[] )( void ) = { f, g };

    void ( **p_func )( void ) = funcs;

    ( *p_func++ )();
    p_func[0]();
}

Voici quelques exemples d'expressions postfixes

postfix-expression:
    primary-expression
    postfix-expression ( argument-expression-listopt )

La définition de un appel de fonction est

( *p )() // a function call

a[n] // using the subscript operator

x++; // using the postfix increment operator

De la norme C (6.5.2.2 Appels de fonction)

1 L'expression qui désigne la fonction appelée 92) doit avoir le type pointeur vers la fonction renvoyant void ou renvoyant un type d'objet complet autre qu'un type de tableau.

Voici quelques exemples d'appels de fonction étranges .:)

( a )
(b+c)
(d*e)
( ( a ) * (b+c) )
( ( ( a ) * (b+c) )-(d*e) )
( x = ( ( ( a ) * (b+c) )-(d*e) ) )

La sortie du programme est

( x = ( ( ( a ) * (b+c) )-(d*e) ) );

Tenez compte du fait que dans ces appels

x = a * (b+c)-(d*e);

expression (* p_func ++) est une expression primaire et une expression p_func [0] est une expression postfix (voir la définition partielle de l'expression postfix ci-dessus)