0

假设在 main() 中，我从名为 TheBuilder 的类创建了一个名为 BOB 的对象指针，我这样做是这样的

TheBuilder *BOB = new TheBuilder();

现在假设我有一个函数，我想将它传递给 main 中的 helloWorld。如何将此 BOB 指针传递给 TheBuilder 对象？如何调用它，helloWorld() 的参数列表是什么样的？

我希望能够修改 BOB 指向的成员函数 helloWorld 内部的对象内部的数据。

我知道它可能有一些 '*' 或 '&' 但我不知道把它们放在哪里。

谢谢

4

5 回答 5

2 
int main()
{
    TheBuilder *BOB = new TheBuilder();
    helloWorld(BOB);
    if (BOB->canWeBuildIt)
        printf("yes we can!");
    delete BOB;
    return 0;
}

void helloWorld(TheBuilder *bob)
{
    bob->canWeBuildIt = true;
}
于 2012-04-21T05:04:06.080 回答
0 
void doSomething1(int x){ 
  //code 
}

这个按值传递变量，无论函数内部发生什么，原始变量都不会改变

void doSomething2(int *x){ 
  //code 
}

在这里，您将类型指针的变量传递给整数。因此，在访问数字时，您应该使用 *x 作为值或使用 x 作为地址

void doSomething3(int &x){ 
  //code 
}

这里和第一个一样，但是无论函数内部发生什么，原始变量也会改变

所以在你的情况下你会写

void helloWorld (TheBuilder* object){
    //Do stuff with BOB
}

void main (){
    TheBuilder *BOB = new TheBuilder();
    helloWorld (BOB);
}
于 2012-04-21T04:55:48.557 回答
0

参数列表将包括一个TheBuilder *参数。例如：

void helloWorld(TheBuilder *theBuilder) { ... }

并称之为：

helloWorld(BOB);

于 2012-04-21T04:56:25.193 回答
0 
class TheBuilder
{
    <class def>
}

void helloWorld (TheBuilder* obj)
{
    <do stuff to obj, which points at BOB>;
}

int main ()
{
    TheBuilder *BOB = new TheBuilder();
    helloWorld (BOB);
    return 0;
}
于 2012-04-21T04:59:11.783 回答
0

如果helloWorld是成员函数，那么您不需要传递任何对象指针：有一个隐式指针，称为this，它指向您调用成员函数的对象：

#include <iostream>

class TheBuilder
{
  public:
    void helloWorld();

    std::string name_;
};

void TheBuilder::helloWorld()
{
    //Here, you can use "this" to refer to the object on which
    //"helloWorld" is invoked

    std::cout << this->name_ << " says hi!\n";

    //In fact, you can even omit the "this" and directly use member variables
    //and member functions

    std::cout << name << " says hi!\n";
}

int main()
{
    TheBuilder alice; //constructs an object TheBuilder named alice
    alice.name_ = "Alice";

    TheBuilder bob; //constructs an object TheBuilder named bob
    bob.name_ = "Bob";

    alice.helloWorld(); //In helloWorld, "this" points to alice
                        //prints "Alice says hi!"

    bob.helloWorld(); //In helloWorld, "this" points to bob
                      //prints "Bob says hi!"
}

事实上，成员函数很像一个自由函数，其隐含参数对应于被操作的对象。当您编写以下代码时：

struct MyClass
{
    int myMemberFunction() {...}
};

MyClass obj;
obj.myMemberFunction();

编译器生成的代码等价于以下内容：

int myMemberFunction(MyClass * this) {...}

MyClass obj;
myMemberFunction(&obj);

但你不必为此烦恼。您需要了解的是，在对象上调用成员函数（面向对象术语中的方法） ，并操作调用它的对象（例如，它可以修改其成员变量（字段））。在成员函数中，您可以通过直接使用它们的名称来访问当前对象成员，也可以显式地使用this指针。

于 2012-04-21T10:10:56.113 回答