base class should be explicitly initialized in the copy constructor

Hi,

I have a question regarding the warning that I get when I compile a program using boost::ublas library. I have to say that I'm not really experienced programmer so I might be doing something really stupid...

Anyway, I'm using WinXP with Mingw (gcc 3.4.5) and boost 1.34-1.

I want to create a simple function that returns a vector. I have it written like this:


===> Definition (file.h )

Code:

#include <boost/numeric/ublas/vector.hpp>
typedef boost::numeric::ublas::vector<double> vec;


vec testfunc (vec &v);

===> Implementation (file.cpp)

Code:

#include "file.h"

vec testfunc (vec &v)
{
    vec v1 = v/2;
    return v1;
}

When I try to compile, I get the following warning:

base class `class boost::numeric::ublas::storage_array<boost::numeri c::ublas::unbounded_array<double, std::allocator<double> > >' should be explicitly initialized in the copy constructor

What am I doing wrong and how can I fix this? The program works, but I'd like to get rid of the warning

Thank you very much for your answers.

Change:

Code:

vec v1 = v/2;

to:

Code:

vec v1(v/2);

The latter is the syntax that must be used when a constructor that takes one argument is declared explicit.

Originally Posted by laserlight

Change:

Code:

vec v1 = v/2;

to:

Code:

vec v1(v/2);

The latter is the syntax that must be used when a constructor that takes one argument is declared explicit.

I changed as you said, but the warnings are still there. Could it be something else wrong?

I changed as you said, but the warnings are still there. Could it be something else wrong?

I have never used that library, so I do not know. I suggest you try a minimal example:

Code:

#include <boost/numeric/ublas/vector.hpp>
typedef boost::numeric::ublas::vector<double> vec;

int main()
{
    vec x;
    vec y(x);
    x = y;
}

What warnings do you get?

With the minimal example you've suggested:

Code:

1  #include <boost/numeric/ublas/vector.hpp>
2  typedef boost::numeric::ublas::vector<double> vec;
3 
4  int main()
5  {
6      vec x;
7      vec y(x);
8      x = y;
9      return 0;
10 }

I get completely the same warnings:

Code:

line 68: instantiated from `boost::numeric::ublas::vector<T, A>::vector(const boost::numeric::ublas::vector<T, A>&) [with T = double, A = boost::numeric::ublas::unbounded_array<double, std::allocator<double> >]'

line 7: instantiated from here

C:\Programs\MinGw\include\boost\numeric\ublas\storage.hpp: line 93: warning: base class `class boost::numeric::ublas::storage_array<boost::numeric::ublas::unbounded_array<double, std::allocator<double> > >' should be explicitly initialized in the copy constructor
:: === Build finished: 0 errors, 1 warnings ===

hmm... I am still not sure what is wrong. Perhaps try an example from the Boost's page:

Code:

#include <boost/numeric/ublas/vector.hpp>
#include <boost/numeric/ublas/io.hpp>

int main () {
    using namespace boost::numeric::ublas;
    vector<double> v (3);
    for (unsigned i = 0; i < v.size (); ++ i)
        v (i) = i;
    std::cout << v << std::endl;
}

This is really a bit weird. If I try the example from the boost, as you suggested, everything is OK. No warnings.

Than I add the following:

Code:

    vector<double> v1 = v/3;

and I get the same warning.

If I add, as you suggested in first post:

Code:

    vector<double> v1(v/3);

the compilation finishes without warnings.

Weird...

Obviously the warning has to do something with the definition (or implementation) of a function. If I add some function (testfunc) to the program, as written below, I get warning. Despite the fact, that I used explicit declaration inside of the function "testfunc". Notice, that I don't use a function at all. I just define and implement it.

The code that I wrote is:

Code:

#include <boost/numeric/ublas/vector.hpp>
#include <boost/numeric/ublas/io.hpp>
typedef boost::numeric::ublas::vector<double> vec;

vec testfunc (vec &v)
{
    vec v1(v/3);
    return v1;
}

int main () {
    vec v (3);
    for (unsigned i = 0; i < v.size (); ++ i)
        v (i) = i;
    std::cout << v << std::endl;
}

If it says that the "base class ... should be explicitly initialized in the copy constructor" could it be that it is the problem of the library, or is the header used in an unusual way. I wonder what it would take to generate this warning without boost?

You get the problem whenever you invoke (and thus cause to be instantiated) the copy constructor of an ublas vector. This causes the unbounded_storage copy constructor to be called and instantiated. And this copy constructor apparently fails to explicitly initialize its base object, which is of type storage_array.

This makes me wonder: what version of Boost do you use? Both my Boost 1.33.1 and my Boost trunk (recently branched to become Boost 1.35) do not have this problem. A 1.33.0 I found lying around doesn't have it either.

In any case, you can ignore the warning. It's simply telling you that some code in Boost is doing implicitly what would be better practice to do explicitly.

anon: To generate the warning, I think this code will suffice. It also demonstrates the reason why the warning is there.

Code:

class A
{
  int x;

public:
  A() : x(0) {}
  void setX(int ax) { x = ax; }
  int getX() { return x; }
};

class B : public A
{
public:
  B() {}
  B(const B&o) {}
};

int main()
{
  B b1;
  b1.setX(5);
  B b2(b1);
  std::cout << b2.getX() << '\n';
}

From the first post: 1.34-1.

--
Mats

Thank you very much for all the answers.

I'm using Boost 1.34-1 from 7th of July 2007 that I got on sourceforge (http://sourceforge.net/project/showf...group_id=7586). To me it looked like this is a stable release. I have also asked the same question on the "boost-user" mailing list, but I got no answer so far.

Anyway, I will ignore the warning, and when new official/stable version is released, I'll get that one.

Ah, yes, 1.34.1 does indeed have the problem I suspected.

If you want, you can fix it yourself, by inserting the following line in boost/numeric/ublas/storage.hpp between lines 92 and 93:

Code:

            storage_array<self_type, ALLOC>(),

Originally Posted by CornedBee

In any case, you can ignore the warning. It's simply telling you that some code in Boost is doing implicitly what would be better practice to do explicitly.

I don't think you can ignore it. The behavior is different in the two cases. See this:

Code:

#include <iostream>

class A
{
  int x;

public:
   A() : x(0) {std::cout << "Default constructor" << std::endl; }
   A(const A &o) : x(o.x) {std::cout << "Copy constructor" << std::endl; }
  void setX(int ax) { x = ax; }
  int getX() { return x; }
};

class B : public A
{
public:
  B() {}
  B(const B&o):A(o) {}
};

int main()
{
  B b1;
  b1.setX(5);
  B b2(b1);
  std::cout << b2.getX() << '\n';
}

Try this with, and without, the highlighted part. You get two different results. In other words, if you do not explicitly initialize the base, the compiler will NOT use its copy constructor but rather its default constructor. In most situations, you want to use the copy constructor on the base in a derived copy constructor.

I think he meant that you can ignore the warning in the specific case of that boost class.