0

所以我有 2 个函数和 1 个类。使用 1 个函数，我想设置存储在类中的整数的值。使用其他功能，我想再次使用这些值。我正在使用指针，因为我认为这将保存在整个程序的内存地址中。

#include <iostream>
using namespace std;


void Function1();
void Function2();
class TestClass
{
public:
    TestClass();
    ~TestClass();
    void SetValue(int localValue)
    {
        *value = localvalue;
    }
    int GetValue()const
    {
        return *value;
    }
private:
    *value;
};

TestClass::TestClass()
{
    value = new int(0);
}

TestClass:
~TestClass()
{
    delete value;
}

int main()
{
    TestClass *tommy = new TestClass; //this didn't work,
    //couldn't use SetValue or Getvalue in functions
    Function1();
    Function2();
    return 0;
}

void Function1()
{
    int randomvalue = 2;
    TestClass *tommy = new TestClass; //because it didnt work in main, i've put it here
    tommy->SetValue(randomvalue);
}

void Function2()
{
    TestClass *tommy = new TestClass;
    cout << tommy->GetValue();
            << endl; //this gave a error, so I put the above in    again
    //but this returns 0, so the value isn't changed
}

那么，有解决我的办法吗？我没有得到任何编译错误，但值没有改变，可能是因为在 Function1 完成后调用了析构函数。那么我该怎么做呢？

4

3 回答 3

1

您需要将您的tommyfrom传递给您的main()每个函数，而不是每次都创建一个新对象，否则您只会丢失Testclass您在函数中创建的新对象，实际上这里会因为您使用new.

就像是：

void Function1(TestClass * tommy) {
    int randomvalue =2;
    tommy->SetValue(randomvalue);
}

然后在main()：

int main() {
    TestClass *tommy = new TestClass; 
    Function1(tommy);
    std::cout << tommy->GetValue() << std::endl;  //  Outputs 2
    delete tommy;
    return 0;
}

不过，这是一个奇怪的用例——这将是您期望成员函数做的事情。这会更好：

int main() {
    TestClass *tommy = new TestClass; 
    tommy->SetValue(2);
    std::cout << tommy->GetValue() << std::endl;  //  Outputs 2
    delete tommy;
    return 0;
}

不需要Function1()and Function2()。无论哪种方式，您都必须修复：

private:
*value;

正如其他人指出的那样，在您的课堂上。

于 2013-10-20T22:53:16.090 回答
0

每次你写的时候new TestClass，你实际上是在创建一个TestClass对象的新实例。新实例不以任何方式与任何现有实例相关，除非属于同一类型。要使单个实例TestClass成为您的函数使用的“那个”，您需要将其作为参数传递给这些函数。

另外——除非绝对必要，否则不要使用指针。

这是您的代码的清理示例，它完成了您正在尝试的内容。

class TestClass
{
   int value;

public:
   TestClass() : value(0)
   {}

   int GetValue() const { return value; }
   void SetValue(int x) { value = x; }
};

// takes a "reference", works somewhat like a pointer but with
// some additional safety guarantees (most likely will not be null)
// This will modify the original passed in TestClass instance.
void SetRandomValue(TestClass& tc)
{
   int random = 2; // not really random...
   tc.SetValue(random);
}

// take a const reference, similar to above comment, but a const
// reference cannot be modified in this scope
void Print(const TestClass& tc)
{
   std::cout << tc.GetValue() << "\n";
}

int main()
{
   // create a TestClass instance with automatic storage duration
   // no need to use a pointer, or dynamic allocation
   TestClass tc;

   // Modify the instance (using reference)
   SetRandomValue(tc);

   // print the instance (using const reference)       
   Print(tc);

   return 0;
}
于 2013-10-20T22:51:02.177 回答
0

您没有将您的 TestClass 传递给任何一个函数，因此它们的函数看不到您制作的 tommy 对象。然后在每个函数中创建一个新的局部变量，它恰好与 main 中的局部变量同名......它们都是独立的对象

于 2013-10-20T22:55:04.697 回答