分配类成员变量时出现C ++分段错误

Question

I have a function "testfunc()" within a class "Test" under a namespace "TEST_NS".

In the main program, I've created a pointer to "Test" and would like to point to the "testfunc()" function. No problem...

I declare a private variable "foo" as a member of "Test", and the "testfunc()" function attempts to change the variable. This results in a segmentation fault.

Why does this happen?

---

I've created a simple example to show my issue. The segfault happens when I set foo = 1; in test.cpp

Here are the files:

main.cpp:

#include <iostream>
#include "test.h"

using namespace std;

int main () {
  TEST_NS::Test * test;
  test->testfunc();
  return 0;
}

test.h:

#include <iostream>

namespace TEST_NS
{
  class Test
  {

  int foo;

  public:
    Test();
    ~Test();

    void testfunc();
  };
}

test.cpp:

#include <iostream>
#include "test.h"

using namespace TEST_NS;

Test::Test() { }

Test::~Test() { }

void Test::testfunc()
{
  std::cout << "This is testfunc()!" << std::endl;

  foo = 1;

}

The code was compiled with

g++ main.cpp test.cpp -o test 

And run with

./test

Answer 1

You need to instantiate an object of your class; try

TEST_NS::Test * test = new TEST_NS::Test();
test->testfunc();

Answer 2

Your main() function needs to change; the preferred way to write it is

int main () {
  TEST_NS::Test test;
  test.testfunc();
  return 0;
}

If you really want to use a pointer (why?), then you should write:

int main () {
  auto test = new TEST_NS::Test();
  test->testfunc();
  delete test;
  return 0;
}

notice the addition of delete test; . But this is bad practice as it creates the potential for memory leaks, especially as more code is added (or if testfunc() throws an exception). If you really need to use pointers, it's much better to use std::unique_ptr<> .

int main () {
  auto test = std::make_unique<TEST_NS::Test>();
  test->testfunc();
  return 0;
}

notice that this also gets rid of the explicit new which is generally a good idea, as well as the delete that had to be added; plus, it's exception-safe.

There is very little reason for "naked" new or delete in modern C++. Note that you can still get a "raw" pointer by using get() , although dereferencing would be preferred

 void testfunc(TEST_NS::Test& test)
 {
    test.testfunc();
 }
 // ...
 testfunc(*test);