C++ segmentation fault when accessing class member in main() - c++

Question

Basically I am creating a mesh composed of nodes and springs and I keep receiving the segmentation fault (core dumped) error when trying to access an element of the nodes vector defined in the Mesh class in main().
When I run a test output within the Mesh class' constructor, I can access the node member just fine. I'm sure it's a memory problem but could anyone explain why this is happening?
Node class:
class Node
{
public:
/// (Non-)magic number indicating that the coordinate has not
/// been classified as pinned or free yet
static int Not_classified_yet;
/// (Non-)magic number indicating that the coordinate is pinned
static int Is_pinned;
/// Constructor: Pass the spatial dimension
Node(const unsigned& dim)
{
// Resize
X.resize(dim,0.0);
Eqn_number.resize(dim,Not_classified_yet);
}
/// Function to add a spring to the node
void add_spring_pt(Spring* spring_pt)
{
Spring_pt.push_back(spring_pt);
}
/// How many springs are attached to this node?
unsigned nspring()
{
return Spring_pt.size();
}
/// Access function to the ith spring connected to the node
Spring*& spring_pt(const unsigned& i)
{
return Spring_pt[i];
}
/// Access function to the position vector of the node
vector<double>& get_vector()
{
return X;
}
/// Access function to the coordinates of the node
double& x(int i)
{
return X[i];
}
/// Access function to the equation number for each coordinate
/// Can be negative if node is pinned in that direction.
int& eqn_number(const unsigned& i)
{
return Eqn_number[i];
}
/// Pin the i-th coordinate
void pin(const unsigned& i)
{
Eqn_number[i]=Is_pinned;
}
/// Is the i-th coordinate pinned?
bool is_pinned(const unsigned& i)
{
return (Eqn_number[i]==Is_pinned);
}
private:
/// Pointers to the springs attatched to the node.
vector<Spring*> Spring_pt;
/// Coordinates of the node
vector<double> X;
/// Vector containing equation indices for each coordinate direction.
/// Can be negative if node is pinned in that direction.
vector<int> Eqn_number;
};
Mesh class:
class Mesh
{
public:
/// constructor (nX contains number of nodes in each direction)
Mesh(const vector<unsigned> nX)
{
/// Function "num_nodes" defined in "myFunctions.cpp" to find the
/// total number of nodes.
unsigned nNodes = num_nodes(nX);
/// Check the dimension of the mesh and and construct a vector
/// of the nodes.
unsigned dim = nX.size();
vector<Node> nodes(nNodes,dim);
//std::cout<< nodes[1].x(0)<<std::endl;
/// Function "num_springs" defined in "myFunctions.cpp" to find the
/// total number of springs.
unsigned nsprings = num_springs(nX);
/// Vector to hold the springs.
vector<Spring> springs(nsprings);
/// Function to assign coordinates to all the nodes.
assign_coordinates(nodes,nX);
}
/// Access function to the ith node of the mesh.
Node& node(const unsigned& i)
{
return nodes[i];
}
/// Function declaration for assigning coordinates to nodes
void assign_coordinates(std::vector<Node>& nodes, std::vector<unsigned> nX);
/// Access function to the ith spring of the mesh.
Spring& spring(const unsigned& i)
{
return springs[i];
}
private:
/// Declare vectors to hold the nodes and springs.
vector<Node> nodes;
vector<Spring> springs;
};
And what I am trying to output from the main():
int main()
{
// create a mesh
// spatial dimensions
unsigned nx = 3;
unsigned ny = 3;
unsigned nz = 3;
vector<unsigned> nX(2);
nX[0] = nx;
nX[1] = ny;
//nX[2] = nz;
Mesh m(nX);
// segmentation fault (core dumped)
std::cout << m.node(6).eqn_number(1) << std::endl;
};
Thanks in advance for any help.

Answer 1

The problem (a problem?) is in Mesh constructor when you define
vector<Node> nodes(nNodes,dim);
I suppose that your intention was initialize the nodes member of the Mesh class; what you get is a nodes variable that is local to the Mesh constructor.
The nodes member of Mesh is initialized with the implicit default constructor, so the vectors in the Nodes (Spring_pt, X and Eqn_number) are initialized with the default std::vector constructor so with zero size.
When you call
m.node(6).eqn_number(1)
with node(6) you call the 7th element of a std::vector of size zero.
Same problem with
std::vector<Spring> springs(nsprings);
in the Mesh constructor: you declare and initialize a springs variable local in the constructor where your intention (I suppose) was initialize the springs member of Mesh.
If I understand correctly your intentions, you should be able to solve the problem writing your constructor as follows
Mesh (const std::vector<unsigned> nX)
: nodes(num_nodes(nX), nX.size()), springs(num_springs(nX))
{ assign_coordinates(nodes,nX); }

Answer 2

At a quick glance it looks like you initialized your mesh with 2 nodes and then went asking for the 7th (indexed starting at 0).
A quick way to check for this is to change nodes[i] to nodes.at(i) which will enable out-of-bounds checking for vector element accesses.