我经常听到人们声称C++是一种上下文敏感的语言。看看下面这个例子：
a b(c);
这是变量定义还是函数声明？这取决于符号的含义。如果是一个变量，那么a b(c);定义了一个类型为a、名为b且被直接初始化为的变量。但是，如果是一种类型，那么a b(c);声明了一个名为b、接受一个参数 c并返回一个a的函数。
如果您查阅上下文无关语言的定义，您会发现所有语法规则的左侧必须仅由一个非终端符号组成。另一方面，上下文敏感语法允许在左侧使用任意终结符和非终结符的字符串。
在《C++程序设计语言》附录A中浏览时，我找不到一条只有唯一非终端符号以外的任何内容的语法规则。这意味着C++是上下文无关的。(当然，每个上下文无关语言在某种意义上来说也都是上下文敏感的，因为上下文无关语言是上下文敏感语言的子集，但这不是重点。)
那么，C++是上下文无关的还是上下文敏感的？
以下是我（目前）最喜欢的演示，说明为什么解析C++（可能）是图灵完备的，因为它展示了一个程序，只有给定的整数是质数时，该程序在语法上才是正确的。
因此，我断言C++既不是无上下文也不是有上下文敏感的。
如果您允许在任何产生式的两侧使用任意符号序列，则会生成乔姆斯基层次结构中的类型0语法（“无限制”），这比上下文敏感语法更强大；无限制语法是图灵完备的。上下文敏感（类型1）语法允许在产生式的左侧使用多个上下文符号，但是相同的上下文必须出现在产生式的右侧（因此称为“上下文敏感”）。[1] 上下文敏感语法等效于线性有界图灵机。
在这个示例程序中，素数计算可以由线性有界图灵机执行，因此它并没有完全证明图灵等价性，但重要的是解析器需要执行计算以执行语法分析。它可以是任何可表示为模板实例化的计算，并且有充分的理由相信C++模板实例化是图灵完备的。例如，请参见Todd L. Veldhuizen's 2003 paper。auto b = foo<IsPrime<234799>>::typen<1>();）一样，这些表达式根本不会产生歧义；它们只是根据上下文以不同的方式解析。在问题的最简表达式中，某些标识符的语法类别取决于它们的声明方式（例如类型和函数），这意味着形式语言必须认识到同一程序中两个任意长度的字符串是相同的（声明和使用）。这可以通过“复制”语法来建模，该语法识别两个连续的完全相同的单词。可以用pumping lemma轻松证明这种语言不是上下文无关的。这种语言的上下文有关语法是可能的，并且在这个问题的答案中提供了一个0型语法：https://math.stackexchange.com/questions/163830/context-sensitive-grammar-for-the-copy-language。最后，这是承诺的程序。如果且仅当IsPrime<N>中的N为质数时，第21行才是语法正确的。否则，typen是一个整数，而不是一个模板，因此typen<1>()被解析为(typen<1)>()，这是语法上不正确的，因为()不是一个语法上有效的表达式。
template<bool V> struct answer { answer(int) {} bool operator()(){return V;}};
template<bool no, bool yes, int f, int p> struct IsPrimeHelper
: IsPrimeHelper<p % f == 0, f * f >= p, f + 2, p> {};
template<bool yes, int f, int p> struct IsPrimeHelper<true, yes, f, p> { using type = answer<false>; };
template<int f, int p> struct IsPrimeHelper<false, true, f, p> { using type = answer<true>; };
template<int I> using IsPrime = typename IsPrimeHelper<!(I&1), false, 3, I>::type;
template<int I>
struct X { static const int i = I; int a[i]; };
template<typename A> struct foo;
template<>struct foo<answer<true>>{
template<int I> using typen = X<I>;
};
template<> struct foo<answer<false>>{
static const int typen = 0;
};
int main() {
auto b = foo<IsPrime<234799>>::typen<1>(); // Syntax error if not prime
return 0;
}
[1] 更准确地说，上下文敏感语法中的每个产生式必须具有以下形式：
αAβ → αγβ
其中A是非终结符，α、β是可能为空的语法符号序列，γ是非空序列。（语法符号可以是终结符或非终结符）。
这可以被理解为只有在上下文[α，β]中才能将A → γ。在上下文无关（第2型）语法中，α和β必须为空。
事实证明，您还可以通过“单调”限制来限制语法，其中每个产生式必须具有以下形式：
α → β，其中|α| ≥ |β| > 0 （|α|表示“α的长度”）
()内放置“0”来实现简单的一个），但我认为这样更有趣，因为它展示了即使要识别一个字符串是否是C ++程序的语法上正确，也需要模板实例化。如果两个分支都编译通过，则我必须更努力地争辩区别是“语义”的论点。有趣的是，尽管我经常被挑战定义“句法”，但没有人提供过“语义”的定义，除了“我认为不是句法的东西”:) - rici首先，你正确地观察到C++标准的语法结尾没有上下文相关规则，因此该语法是无上下文的。
然而，该语法并不能精确描述C++语言，因为它会产生非C++程序，例如:
int m() { m++; }
typedef static int int;
定义为“合法的 C++ 程序集”的 C++ 语言不是上下文无关的（仅要求变量声明就可能证明它不是上下文无关的）。理论上，您可以在模板中编写图灵完备程序，并根据其结果使程序不合规。
现在，（无知的）人们（通常不是语言理论家，而是解析器设计师）通常在以下一些含义上使用“非上下文无关”
标准后面的语法不满足这些类别（即存在歧义，不是 LL(k)...），因此对于它们来说，C++ 语法“不是上下文无关的”。从某种意义上说，他们是正确的，因为很难生成可工作的 C++ 解析器。
请注意，这里使用的属性与上下文无关语言只有弱连接 - 歧义与上下文敏感没有任何关系（实际上，上下文敏感规则通常有助于消除产生式的歧义），其他两者仅仅是上下文无关语言的子集。并且解析上下文无关语言不是线性过程（尽管解析确定性上下文无关语言是线性的）。
a b(c); 的论点，并且部分满足了最初的问题前提，即“经常听到”的主张上下文敏感性是由于歧义......特别是对于 语法 ，即使在MVP中也实际上没有歧义。 - Lightness Races in Orbit是的。以下表达式在不同的类型解析上下文中具有不同的操作顺序：
编辑：当实际操作顺序变化时，使用“常规”编译器在装饰AST之前解析它（传播类型信息）变得非常困难。与此相比，其他上下文敏感的事情“相当容易”，但这并不意味着模板评估很容易。
#if FIRST_MEANING
template<bool B>
class foo
{ };
#else
static const int foo = 0;
static const int bar = 15;
#endif
跟随着：
static int foobar( foo < 2 ? 1 < 1 : 0 > & bar );
几乎所有编程语言的语法都是无上下文的。通常，它以扩展的Backus-Naur形式或无上下文语法的形式给出。
然而，即使程序符合编程语言定义的无上下文语法，它也不一定是一个有效的程序。有许多非无上下文属性，程序必须满足才能成为有效的程序。例如，最简单的这种属性是变量的作用域。
总之，C++是否是无上下文取决于你提出的问题。
VARDECL: TYPENAME IDENTIFIER，但实际上你不能这样做，因为在CF（上下文无关）的级别上你不能区分类型名称和其他标识符。另一个例子：在CF级别上，你无法确定是否将a*b解析为变量声明（指向a的指针类型的b）还是乘法运算。 - LaC是的，C++ 是上下文敏感的，非常上下文敏感。不能使用上下文无关的解析器仅通过解析文件来构建语法树，因为在某些情况下，您需要知道以前的符号才能决定（即在解析时构建符号表）。
第一个例子：
A*B;
这是一个乘法表达式吗？
还是这是声明变量 B 为类型为A的指针吗？
如果 A 是一个变量，那么它是一个表达式，如果 A 是类型，则是指针声明。
第二个例子：
A B(bar);
bar类型作为参数的函数原型吗？A的变量B，并使用bar常量作为初始化器调用了A的构造函数吗？bar是一个变量还是一个类型。class Foo
{
public:
void fn(){x*y;}
int x, y;
};
在解析时构建符号表无法帮助的情况是，x和y的声明出现在函数定义之后。因此，您需要先扫描类定义，然后在第二次遍历中查看方法定义，以确定x*y是一个表达式，而不是指针声明或其他什么。
A B();即使在函数定义中也是一个函数声明。寻找最令人烦恼的解析... - AProgrammer我感觉在“上下文相关”这个术语的正式定义和非正式用法之间存在一些混淆。前者有一个明确定义的含义，而后者用于表示“需要上下文才能解析输入”的意思。
这个问题也在这里被问到了：Context-sensitivity vs Ambiguity。
这是一个无上下文文法：
<a> ::= <b> | <c>
<b> ::= "x"
<c> ::= "x"
这是一个不确定的语法，因此为了解析输入的"x"，你需要一些上下文（或者容忍不确定性，或者发出警告："警告：E8271 - 第115行的输入存在歧义"）。但它肯定不是一种上下文敏感的语法。
C++使用GLR解析器进行解析，这意味着在解析源代码时，解析器可能会遇到歧义，但它应该继续并决定稍后使用哪个语法规则。
另外，请参阅：
请记住，上下文无关语法无法描述编程语言语法的所有规则。例如，属性语法用于检查表达式类型的有效性。
int x;
x = 9 + 1.0;
你无法使用上下文无关文法来描述以下规则： 赋值号右侧应该与左侧的类型相同。
没有一种类似Algol的语言是上下文无关的，因为它们有规则来限制表达式和语句中标识符出现的类型，并且在声明和使用之间可以出现无限数量的语句。
通常的解决方案是编写一个上下文无关的解析器，实际上接受有效程序的超集，并将上下文敏感部分放入与规则相关的“语义”代码中。
C++通过其图灵完备的模板系统远远超越了这个范围。请参见Stack Overflow Question 794015。
A variable_decl ::= <type> <identifier> '(' initializer ')' ';'
B function_decl ::= <type> <identifier> '(' param_decl ')' ';'
A ::= [declaration of X as value]
B ::= [declaration of X as type]