Non-static const member, can't use default assignment operator

A program I'm expanding uses std::pair<> a lot.

There is a point in my code at which the compiler throws a rather large:

Non-static const member, 'const Ptr<double, double> std::pair<const Ptr<double, double>, const double*>::first' can't use default assignment operator

I'm not really sure what this is referring to? Which methods are missing from the Ptr class?

The original call that causes this problem is as follows:

vector_of_connections.pushback(pair(Ptr<double,double>,WeightValue*));

Where it's putting an std::Pair<Ptr<double,double>, WeightValue*> onto a vector, where WeightValue* is a const variable from about 3 fuctions back, and the Ptr<double,double> is taken from an iterator that works over another vector.

For future reference, Ptr is a pointer to a Node object.

From stackoverflow

• At least mention which object the compiler is complaining about. Most probably you are missing a custom assignment member. If you don't have one, the default one kicks in. Probably, you also have a const member in that class (whose objects are being assigned) and since a const member cannot be changed you hit that error.

  Another approach: Since it's a class const, I suggest that you change it to a static const if that makes sense.

• You have a case like this:

  struct sample {
      int const a; // const!
  
      sample(int a):a(a) { }
  };
  

  Now, you use that in some context that requires sample to be assignable - possible in a container (like a map, vector or something else). This will fail, because the implicitly defined copy assignment operator does something along this line:

  // pseudo code, for illustration
  a = other.a;
  

  But a is const!. You have to make it non-const. It doesn't hurt because as long as you don't change it, it's still logically const :) You could fix the problem by introducing a suitable operator= too, making the compiler not define one implicitly. But that's bad because you will not be able to change your const member. Thus, having an operator=, but still not assignable! (because the copy and the assigned value are not identical!):

      struct sample {
      int const a; // const!
  
      sample(int a):a(a) { }
  
      // bad!
      sample & operator=(sample const&) { }
  };
  

  However in your case, the apparent problem apparently lies within std::pair<A, B>. Remember that a std::map is sorted on the keys it contains. Because of that, you cannot change its keys, because that could easily render the state of a map invalid. Because of that, the following holds:

  typedef std::map<A, B> map;
  map::value_type <=> std::pair<A const, B>
  

  That is, it forbids changing its keys that it contains! So if you do

  *mymap.begin() = make_pair(anotherKey, anotherValue);
  

  The map throws an error at you, because in the pair of some value stored in the map, the ::first member has a const qualified type!

• As far as I can tell, someplace you have something like:

  // for ease of reading 
  typedef std::pair<const Ptr<double, double>, const double*> MyPair;
  
  MyPair myPair = MAKEPAIR(.....);
  myPair.first = .....;
  

  Since the members of MyPair are const, you can't assign to them.