C++ global char pointer? - c++

Question

Part of a larger program I am making requires a path to be read in from the command line and stored in a class. Because paths can be an arbitrary size and it's needed in multiple functions, I store it in a char* in the header file. But, for some reason, when I assign a value to it, the program segfaults.
The debugger (gdb) shows the following:
Program received signal SIGSEGV, Segmentation fault.
0x00007ffff7b4828a in std::basic_istream<char, std::char_traits<char> >& std::operator>><char, std::char_traits<char> >(std::basic_istream<char, std::char_traits<char> >&, char*) ()
from /usr/lib/libstdc++.so.6
Here's the program I wrote to demonstrate the problem:
test.cpp:
#include "test.h"
#include <iostream>
#include <cstring>
Test::Test() {
filepath = NULL;
}
void Test::set_path(char* string) {
char temp[strlen(string) + 1];
strcpy(filepath, temp);
}
char * Test::get_path() {
return filepath;
}
int main(int argc, char *argv[]) {
std::cout << "Enter a file path: ";
char *temp;
std::cin >> temp;
Test *temp2 = new Test();
temp2->set_path(temp);
std::cout << "Path: " << temp2->get_path() << std::endl;
}
test.h:
#ifndef TEST_H
#define TEST_H
class Test {
private:
char *filepath;
public:
Test();
void set_path(char *);
char * get_path();
};
#endif // TEST_H
I'm not sure why it crashes. Is there something wrong with the method I'm doing this? Also, rather than just switching to strings, I'd like to find out more about this problem.
Thanks in advance!

Answer 1

temp (inside main) is uninitialized and not pointing to any valid allocated block of memory, therefore the line:
std::cin >> temp;
is causing input to be written into some unknown part of memory, causing undefined behaviour. You should either:
Make temp a char[] and only read in an amount of characters that will fit in the buffer.
Point temp to a valid buffer.
Better yet, make temp an std::string, and let the std::string class worry about the memory management.
You're also going to be having a similar problem with filePath after you fix the above problem. filePath is being set to NULL in the Test constructor, and then you're copying temp to the block of memory pointed by filePath in Test::set_path:
strcpy(filepath, temp);
NULL refers to an address that you're not allowed to dereference. You should change all of your C-strings to std::strings and use the std::string member functions and overloaded operators to deal with strings in C++.

Answer 2

You call strcpy without allocating memory for the string to be copied in set_path. The manual page clearly states that dest must be large enough to contain the string in src. Besides you copy from an empty temporary. Although, your crash appears early, when you read from cin into an uninitialized pointer.
Use std::string.
#include <iostream>
class Foo
{
public:
Foo(const std::string& s) : s_(s) {} ;
private:
std::string s_;
};
int main()
{
std::string f;
std::cin >> f;
std::cout << f << std::endl;
Foo foo = Foo(f);
return 0;
}
If you really preffer what you are doing:
class Foo
{
public:
Foo(const char* s) {
size_t size = strlen(s);
s_ = new char[size + 1];
// safer
strncpy(s_, s, size + 1);
} ;
private:
char* s_;
};
int main()
{
char buffer[1024];
// be save
buffer[1023] = '\0';
Foo foo = Foo(buffer);
return 0;
}
The second example is still broken. It is missing a proper destructor, copy constructor and assignment operator. I'll leave this as an exercise.

Answer 3

Test::Test() {
filepath = NULL;
}
void Test::set_path(char* string) {
char temp[strlen(string) + 1];
strcpy(filepath, temp);
}
I'm not sure what you thought that strcpy was going to do, but what it does is copy from temp, which is uninitialized, to filepath, which is NULL. So neither parameter makes any sense.