语言兼容性

// deletes implicit copy constructor:

__block
__block
inline int add(int i, int j) { return i + j; }

int main() {
  int i = add(4, 5);
  return i;
}

Undefined symbols:
  "_add", referenced from:
      _main in cc-y1jXIr.o

<*mmintrin.h>
_mm_xor_ps
_mm256_addsub_pd
__builtin_ia32_paddw128
  builtins.py *.c *.h

__builtin_ia32_paddw128
lvalue.c:2:3: error: assignment to cast is illegal, lvalue casts are not supported
  (int*)addr = val;
  ^~~~~~~~~~ ~

  addr = (float *)val;

__block
__block
__block
__block
int fetch_object_state(struct MyObject *c) {
  if (!c->active) goto error;

  __block int result;
  run_specially_somehow(^{ result = c->state; });
  return result;

 error:
  fprintf(stderr, "error while fetching object state");
  return -1;
}

t.c:3:5: error: goto into protected scope
    goto error;
    ^
t.c:5:15: note: jump bypasses setup of __block variable
  __block int result;
              ^

__block
  {
    __block int result;
    run_specially_somehow(^{ result = c->state; });
    return result;
  }

__block
x
int f0() {
  __block int x;
  return ^(){ return x; }();
}

__block
  asm("add %al, (%rax)");
  asm("addw $4, (%rax)");
  asm("add $4, (%rax)");

%al
<inline asm>:3:1: error: ambiguous instructions require an explicit suffix (could be 'addb', 'addw', 'addl', or 'addq')
add $4, (%rax)
^

super.m:11:12: error: cannot cast 'super' (it isn't an expression)
  [(Super*)super add:4];
   ~~~~~~~~^

  [super add:4];

sizeof.m:4:14: error: invalid application of 'sizeof' to interface 'NSArray' in non-fragile ABI
  int size = sizeof(NSArray);
             ^     ~~~~~~~~~

  class_getInstanceSize([NSArray class])

struct objc_object*
struct objc_selector*
struct objc_class*
id
SEL
Class
t.mm:11:2: error: no matching function for call to 'f'
        f((struct objc_object *)p);
        ^
t.mm:5:6: note: candidate function not viable: no known conversion from 'struct objc_object *' to 'id' for 1st argument
void f(id x);
     ^

id
SEL
Class
@interface XX
int a;         // not allowed in clang
int b = 1;     // not allowed in clang
extern int c;  // allowed
@end

-Werror=vla
int size = ...;
const int size = ...;
std::vector
new Type[]
delete[]
template <typename T> T Squared(T x) {
  return Multiply(x, x);
}

int Multiply(int x, int y) {
  return x * y;
}

int main() {
  Squared(5);
}

my_file.cpp:2:10: error: call to function 'Multiply' that is neither visible in the template definition nor found by argument-dependent lookup
  return Multiply(x, x);
         ^
my_file.cpp:10:3: note: in instantiation of function template specialization 'Squared<int>' requested here
  Squared(5);
  ^
my_file.cpp:5:5: note: 'Multiply' should be declared prior to the call site
int Multiply(int x, int y) {
    ^

Multiply
Multiply
int
Multiply
#include <iostream>

template<typename T>
void Dump(const T& value) {
  std::cout << value << "\n";
}

namespace ns {
  struct Data {};
}

std::ostream& operator<<(std::ostream& out, ns::Data data) {
  return out << "Some data";
}

void Use() {
  Dump(ns::Data());
}
my_file2.cpp:5:13: error: call to function 'operator<<' that is neither visible in the template definition nor found by argument-dependent lookup
  std::cout << value << "\n";
            ^
my_file2.cpp:17:3: note: in instantiation of function template specialization 'Dump<ns::Data>' requested here
  Dump(ns::Data());
  ^
my_file2.cpp:12:15: note: 'operator<<' should be declared prior to the call site or in namespace 'ns'
std::ostream& operator<<(std::ostream& out, ns::Data data) {
              ^

operator<<
std::basic_ostream
ns::Data
std
ns
operator<<
使用
operator<<
template <typename T> struct Base {
  void DoThis(T x) {}
  static void DoThat(T x) {}
};

template <typename T> struct Derived : public Base<T> {
  void Work(T x) {
    DoThis(x);  // Invalid!
    DoThat(x);  // Invalid!
  }
};

Derived
my_file.cpp:8:5: error: use of undeclared identifier 'DoThis'
    DoThis(x);
    ^
    this->
my_file.cpp:2:8: note: must qualify identifier to find this declaration in dependent base class
  void DoThis(T x) {}
       ^
my_file.cpp:9:5: error: use of undeclared identifier 'DoThat'
    DoThat(x);
    ^
    this->
my_file.cpp:3:15: note: must qualify identifier to find this declaration in dependent base class
  static void DoThat(T x) {}

DoThis
DoThat
Derived
Base<T>
T
this->
  void Work(T x) {
    this->DoThis(x);
    this->DoThat(x);
  }

  void Work(T x) {
    Base<T>::DoThis(x);
    Base<T>::DoThat(x);
  }

DoThis
  class IOOptions;
  template <class T> bool read(T &value) {
    IOOptions opts;
    return read(opts, value);
  }

  class IOOptions { bool ForceReads; };
  bool read(const IOOptions &opts, int &x);
  template bool read<>(int &);

opts.ForceReads
init()
innit()
  template <class T> class Processor {
    ...
    void init();
    ...
  };
  ...
  template <class T> void process() {
    Processor<T> processor;
    processor.innit();       // <-- should be 'init()'
    ...
  }

Processor<T>
Processor
  template <> class Processor<char*> {
    void innit();
  };

process()
T = char*
class
struct
const
class Foo {
 public:
  // The compiler-supplied default constructor works fine, so we
  // don't bother with defining one.
  ...
};

void Bar() {
  const Foo foo;  // Error!
  ...
}

class Foo {
 public:
  Foo() {}
  ...
};

void Bar() {
  const Foo foo;  // Now the compiler is happy.
  ...
}

void f(int a, int a);

struct X {
  X(X&&); // deletes implicit copy constructor:
  // X(const X&) = delete;
};

void f(X x);
void g(X x) {
  f(x); // error: X has a deleted copy constructor
}

shared_ptr
shared_ptr
@interface Base @end
@interface Derived : Base @end

void f(Derived *p);
void g(Base *p) {
  f(p);
}

downcast.mm:6:3: error: no matching function for call to 'f'
  f(p);
  ^
downcast.mm:4:6: note: candidate function not viable: cannot convert from
      superclass 'Base *' to subclass 'Derived *' for 1st argument
void f(Derived *p);
     ^

  f((Derived *)base);

@interface I {
int cls;
}
+ (int)class;
@end

@implementation  I
- (int) Meth { return I.class; }
@end

语言兼容性

C 兼容性

C99 内联函数

“缺失”的向量 __builtin 函数

左值转换

跳转到内部`__block`变量范围

未初始化`__block`变量

内联汇编

Objective-C 兼容性

super 的转换

接口的大小

内部 Objective-C 类型

@interface 或 @protocol 中的 C 变量

C++ 兼容性

变长数组

模板中的非限定查找

类模板的依赖基类中的非限定查找

模板中的不完整类型

没有有效实例化的模板

类类型 const 变量的默认初始化需要用户定义的默认构造函数

参数名称查找

C++11 兼容性

已删除的特殊成员函数

Objective-C++ 兼容性

隐式向下转换

使用 `class` 作为属性名

语言兼容性

C 兼容性

C99 内联函数

“缺失”的向量 __builtin 函数

左值转换

跳转到内部__block变量范围

未初始化__block变量

内联汇编

Objective-C 兼容性

super 的转换

接口的大小

内部 Objective-C 类型

@interface 或 @protocol 中的 C 变量

C++ 兼容性

变长数组

模板中的非限定查找

类模板的依赖基类中的非限定查找

模板中的不完整类型

没有有效实例化的模板

类类型 const 变量的默认初始化需要用户定义的默认构造函数

参数名称查找

C++11 兼容性

已删除的特殊成员函数

Objective-C++ 兼容性

隐式向下转换

使用 class 作为属性名

跳转到内部`__block`变量范围

未初始化`__block`变量

使用 `class` 作为属性名