Constructor calling constructor: SIGSEGV

I have a class with two constructors, one constructor has no arguments, the other constructor has one argument. The constructor with no arguments calls the other with a default argument. The issue is, that when I dynamically allocate memory with the first constructor, it does not remain set as control goes to the other constructor. I don't think i've made myself clear, so I will write some code to show you what I mean.

Code:

---

class Aclass {
  public:
    Aclass();
    Aclass(int);
    void test();
  private:
    int *var;
}

...

Aclass::Aclass()
{
  Aclass(10);
}

Aclass::Aclass(int x)
{
  var = new int[x]; // allocate memory
  var[0] = x*x;
}

void Aclass::test()
{
  // here var is NULL!
  var[1] = 3; // SIGSEGV
  // but if this object was created by calling Aclass(10) directly, there is no problem
}

---

You need to use Delegating Constructors of C++11 here.

my first tip do not allocate in constructor bcause it may cause mem leaks - i read that somewhere
do it in a private init proc so u don't need to call the contructor again that should work

Well line 14 is creating another instance of your class, which then gets thrown away at line 15.

If you step through this with the debugger, you should see that your var member for the current instance isn't being modified.

I wouldn't really call that a default argument, if you want to use a true default argument then a single constructor can do what you are attempting:

Code:

---

class Aclass {
  public:
    Aclass(int);
    void test();
  private:
    int *var;
};
 
...
 
Aclass::Aclass(int x = 10)
{
  var = new int[x]; // allocate memory
  var[0] = x*x;
}
 
void Aclass::test()
{
  var[1] = 3;
}

---

In this case if you call the Aclass constructor without an argument, the default value of x will be set to 10 for you automatically.

Quote:

---

Originally Posted by hk_mp5kpdw

I wouldn't really call that a default argument, if you want to use a true default argument then a single constructor can do what you are attempting:

Code:

---

class Aclass {
  public:
    Aclass(int);
    void test();
  private:
    int *var;
};
 
...
 
Aclass::Aclass(int x = 10)
{
  var = new int[x]; // allocate memory
  var[0] = x*x;
}
 
void Aclass::test()
{
  var[1] = 3;
}

---

In this case if you call the Aclass constructor without an argument, the default value of x will be set to 10 for you automatically.

---

Thanks. I will probably do that.
Not sure... someone else's reply might be better. This is only my first C++ program. I have programmed in C and Java ( Got really good at Java! ) and that's why I got as far as I did without running into anything strange...

Thanks everybody.

Quote:

---

Originally Posted by manasij7479

You need to use Delegating Constructors of C++11 here.

---

How? Looked on wikipedia, did not make sense.

Quote:

---

Originally Posted by NA9x2000

my first tip do not allocate in constructor bcause it may cause mem leaks - i read that somewhere
do it in a private init proc so u don't need to call the contructor again that should work

---

My first tip would be that your first tip is rubbish. Allocating memory is best done in a constructor. Please don't try and pass on misunderstood, badly remembered, untrue, and unquoted rubbish information.

I read somewhere that 50% of all statistics are made up.
Bugs cause memory leaks. You should probably avoid bugs instead.

Quote:

---

Originally Posted by iMalc

Please don't try and pass on misunderstood, badly remembered, untrue, and unquoted rubbish information.

---

People should know that there's three levels of advice at cprogramming:

1) Those that don't know what they're talking about.
2) Me.
3) Those that do know what they're talking about.

Choose wisely.

Quote:

---

Originally Posted by Benji Wiebe

How? Looked on wikipedia, did not make sense.

---

Code:

---

#include<iostream>
class foo
{
public:
        foo(int x_):x(x_){};//Normal constructor taking an argument

        foo():foo(10){};//Default Constructor calling the above constructor with a default value

        int x;
};
int main()
{
        foo y;
        std::cout<<y.x;
        return 0;

}

---

You'll need a compiler supporting it though.
GCC versions >=4.7 do, as I verified this on my machine. (with the -std=c++11 flag, if this is the first C++11 feature you're seeing.)

If you don't use GCC, you can simple make two constructors which both call some common initialization routine function, that would initialize your pointers and all.