是C'；s->；等价于Objective-C中的点表示法 我正在做Box 2D编程，而且我要做的是，我是一个完全的C++和C语言的NOB，我是一个Objul-C的家伙，这就是为什么我对语言的理解变得非常困难。特别是： ->

基本上，我理解这用于引用不同的方法或函数或变量/属性，如下所示：

body->GetWorld()->DestroyBody(body);

这是否等同于Objective-C中的点表示法：

// made up example
[body.world destroyBody];

或

---

还是类似的？我真的不明白。有人能告诉我这是什么吗。谢谢

> P> >我不知道ObjuleC，但我可以解释<代码> > >代码>和<代码> ./COD> C和C++，希望有帮助。

是允许您访问结构/类实例成员的运算符

a->b

与

（*a）.b

相同-因此它首先取消引用指针，然后访问指针指向的实例的成员

---

此外，Luchian还提到了一个例子——给定类的

操作符->（）

的重载。如果你使用的类超载这个操作符，行为将不同，由类定义它可以返回几乎所有它想要的。

< P>我对ObjuleC没有太多的了解，但是我可以尝试给你一些关于C++的帮助：假设你在C++中定义了一个类<代码> Foo，用一个方法<代码> Bar（）< /C> >：

如果在堆栈上分配

Foo

的实例，则使用点表示法（

）调用方法

bar（）

：

如果有指向

Foo

实例的指针，则使用箭头符号（

->

）调用方法

bar（）

：

---

（更复杂的是，还有一些引用，它们具有值语法和指针语义：如果您有对

Foo

（例如

Foo&f

）的引用，您仍然使用点表示法：

f.bar（）；

）

用于访问对象成员，

->

用于通过指针访问成员通常<代码>运算符->可以重载，这意味着您也可以在对象上使用它：

struct X
{
   X* other;
   X* operator->() {return other;}
};

X x;
x->other;

---

在这种情况下，

x->other

不是指

x.other

，而是指

x.other.other

：D< /P> < P>不，使用<代码> .<代码>访问Objto-C属性与 > >代码>或<代码> .<代码>访问C和C++中的Stutt和类成员。

Objective-C属性访问器处理类型为

id

（指针类型）的值，但使用特殊的命名约定来决定其实际用途。它可以直接访问属性数据成员，使其类似于数据成员访问的

->

。或者它可以查找用于获取和/或设置属性值的特殊函数，在这种情况下，它是用于消息发送的语法

除了C++中运算符重载的情况，>->/COD>总是与引用指针无关，然后访问引用的成员。code>a->b相当于

（*a）.b

b

可能是成员函数的数据成员，但被访问的成员将具有

b

中提到的确切名称，而不是基于任何特殊命名约定的某些变体。如果<代码> b <代码>命名一个成员函数，那么它可能是一个虚函数，它与Objtovi.C++中的消息发送有一些相似之处，但并不相同。<代码> B <代码>也可能是C++中的一个重载成员函数，在Objul-C.<／P>中没有等价的函数。

---

在Objective-C中添加用于访问对象属性的

语法违反了Objective-C的设计原则，即新特性应该是新的。使用

@

，

[]

消息发送语法和定义Objective-C对象的特殊关键字是Objective-C以前遵循此设计原则的示例。

这是Objective-C代码

@interface Foo : NSObject
{
  NSInteger _a;
}
@property (nonatomaic, assign) NSInteger a;
@end

@implement Foo
@synthesize a = _a;
@end

你知道“合成”这个短语。 @综合创建以下代码

- (NSInteger)a
{
  return _a;
}


- (void)setA:(NSInteger)aa
{
  return _a = aa;
}

让我们访问属性a

void main()
{
  Foo foo = [[Foo alloc] init];
  foo.a = 1;
}

必须将foo.a指定为1。 但编译器调用如下

void main()
{
  Foo foo = [[Foo alloc] init];
  [foo setA:1];
}

foo.a=1且[foo setA:1]相同。 foo.a=1调用[foo setA:1]

贝娄，用C写的

class Foo
{
private:
  int _a;
public:
  int getA();
  void setA(const int aa);
};

int Foo::getA()
{
   return _a;
}
void Foo::setA(const int aa)
{ 
   _a = aa;
}

// local allocation example.

void main()
{
  Foo foo;
  foo.setA(1);
}

// Heap allocation example.
void main()
{
   Foo *foo = new Foo();
   foo->setA(1);
   delete foo;
}

// Pointer (like object objectve-c).
void main()
{
   Foo foo1;
   foo1.setA(1);

   Foo *foo2 = &foo1;
   foo2->setA(2);

   printf("result>>> %d, %d", foo1.a, foo2->a); 
}

result>>>  2, 2

foo1.a和foo2->a也是2。 Objective-C示例如下

void main()
{
   Foo *foo1 = [[Foo alloc] init];
   foo1.a = 1;

   Foo *foo2 = foo1;
   foo2.a = 2;

   NSLog(@"result>>> %d, %d", foo1.a, foo2.a);
}

result>>>  2, 2

祝你今天愉快。

---

谢谢。

AFAIK Objective-C也有

->

。Objective C是C。。。因此，您可以完美地使用->在目标C中。好的，这些数字，谢谢您的回答！我会在9分钟内打勾，到时候我可以做it@RohanKapur这并不总是正确的。在目标C中完全没有运算符重载；）@VistoCouMuZe，是的，但是OP问了C++中的代码> > >代码>。堆栈和堆分配与使用

->

或

无关：唯一重要的是所使用的表达式的类型。@akappa:我只是给出了一些具体的例子来解释点与箭头语法的概念。我知道如果您在堆栈上分配

Foo

（

Foo f；

），然后有一个指向相同

Foo

（

Foo*pf=&f；

）的指针，语法仍然是

pf->bar（）。我在向语言初学者解释时尽量简单，避免混淆。“一切都应该尽可能简单，但不能简单”。举例说明一件普通的事情是可以的，试图通过列举一些例子来简化一件事情是非常错误的，并且可能具有欺骗性，特别是如果你没有明确地说这些只是例子的话。例如，他可以编写类似于
Foo*x=newfoo（）；Foo&y=*x；y->method（）或
foox；Foo*y=&x；y、 方法（）
并想知道为什么它不起作用。@akappa：我认为您的代码示例不必要且复杂，不利于学习过程的开始：它们会产生混乱（不过，我已经在参考资料中添加了一个小注释）
void main()
{
  Foo foo = [[Foo alloc] init];
  foo.a = 1;
}

void main()
{
  Foo foo = [[Foo alloc] init];
  [foo setA:1];
}

class Foo
{
private:
  int _a;
public:
  int getA();
  void setA(const int aa);
};

int Foo::getA()
{
   return _a;
}
void Foo::setA(const int aa)
{ 
   _a = aa;
}

// local allocation example.

void main()
{
  Foo foo;
  foo.setA(1);
}

// Heap allocation example.
void main()
{
   Foo *foo = new Foo();
   foo->setA(1);
   delete foo;
}

// Pointer (like object objectve-c).
void main()
{
   Foo foo1;
   foo1.setA(1);

   Foo *foo2 = &foo1;
   foo2->setA(2);

   printf("result>>> %d, %d", foo1.a, foo2->a); 
}

result>>>  2, 2

void main()
{
   Foo *foo1 = [[Foo alloc] init];
   foo1.a = 1;

   Foo *foo2 = foo1;
   foo2.a = 2;

   NSLog(@"result>>> %d, %d", foo1.a, foo2.a);
}

result>>>  2, 2