Please help!!

[Anmol444]

In this code:

// Ex8_10.cpp
// Using a class template
#include <iostream>
#include <utility>                          // For operator overload templates
using std::cout;
using std::endl;
using std::move;
using namespace std::rel_ops;
        
class CBox                                  // Class definition at global scope
{
  public:
    // Constructor definition
    explicit CBox(double lv = 1.0, double wv = 1.0, double hv = 1.0): m_Height(hv)
    {
      m_Length = std::max(lv, wv);
      m_Width = std::min(lv, wv);

      // Length is now greater than or equal to width 
      if(m_Height > m_Length)
      {
        m_Height = m_Length;
        m_Length = hv;

        // m_Height is still greater than m_Width so swap them
        double temp = m_Width;
        m_Width = m_Height;
        m_Height = temp;
      }
      else if( m_Height > m_Width)
      {
        m_Height = m_Width;
        m_Width = hv;
      }
    }
        
    // Function to calculate the volume of a box
    double Volume() const
    {
      return m_Length*m_Width*m_Height;
    }
        
    // Operator function for 'less than' that
    // compares volumes of CBox objects.
    bool operator<(const CBox& aBox) const
    {
      return this->Volume() < aBox.Volume();
    }

    // 'Less than' operator function to compare a CBox object volume with a constant
    bool operator<(const double& value) const
    {
      return this->Volume() < value;
    }

    // 'Greater than' function to compare a CBox object volume with a constant
    bool operator>(const double& value) const
    {
      return this->Volume() > value;
    }
        
    // Overloaded equality operator
    bool CBox::operator==(const CBox& aBox) const
    {
      return this->Volume() == aBox.Volume();
    }

    // Function to add two CBox objects
    CBox operator+(const CBox& aBox) const
    {
      // New object has larger length & width, and sum of heights
      return CBox(m_Length > aBox.m_Length ? m_Length : aBox.m_Length,
                  m_Width > aBox.m_Width   ?  m_Width : aBox.m_Width,
                  m_Height + aBox.m_Height);
    }

    // Function to show the dimensions of a box
    void ShowBox() const
    {
      cout << m_Length << " " << m_Width  << " " << m_Height << endl;
    }
        
  private:
    double m_Length;                        // Length of a box in inches
    double m_Width;                         // Width of a box in inches
    double m_Height;                        // Height of a box in inches
};
        
// CSamples class template definition
template <class T> class CSamples
{
  public:
    // Constructors
    CSamples(const T values[], int count);
    CSamples(const T& value);
    CSamples(T&& value);
    CSamples() : m_Free(0) {}
        
    bool Add(const T& value);               // Insert a value
    bool Add(T&& value);                    // Insert a value with mve semantics
    T Max() const;                          // Calculate maximum
        
  private:
    static const size_t maxSamples = 100;   // Maximum number od sample
    T m_Values[maxSamples];                 // Array to store samples
    int m_Free;                             // Index of free location in m_Values
};

// Constructor template definition to accept an array of samples
template<class T> CSamples<T>::CSamples(const T values[], int count)
{
  m_Free = count < maxSamples ? count : maxSamples;       // Don't exceed the array
  for(int i = 0; i < m_Free; i++)
    m_Values[i] = values[i];                // Store count number of samples
}
        
// Constructor to accept a single sample
template<class T> CSamples<T>::CSamples(const T& value)
{
  m_Values[0] = value;                      // Store the sample
  m_Free = 1;                               // Next is free
}
        
// Constructor to accept a temporary sample
template<class T> CSamples<T>::CSamples(T&& value)
{
  cout << "Move constructor." << endl;
  m_Values[0] = move(value);                // Store the sample
  m_Free = 1;                               // Next is free
}
        
// Function to add a sample
template<class T> bool CSamples<T>::Add(const T& value)
{
  cout << "Add." << endl;
  bool OK = m_Free < maxSamples;                   // Indicates there is a free place
  if(OK)
    m_Values[m_Free++] = value;             // OK true, so store the value
  return OK;
}
        
template<class T> bool CSamples<T>::Add(T&& value)
{
  cout << "Add move." << endl;
  bool OK = m_Free < maxSamples;                   // Indicates there is a free place
  if(OK)
    m_Values[m_Free++] = move(value);       // OK true, so store the value
  return OK;
}
 
// Function to obtain maximum sample
template<class T> T CSamples<T>::Max() const
{
  T theMax = m_Values[0];                   // Set first sample as maximum
  for(int i = 1; i < m_Free; i++)           // Check all the samples
    if(theMax < m_Values[i])
      theMax = m_Values[i];                 // Store any larger sample
  return theMax;
}
        
int main()
{
  CBox boxes[] = {                          // Create an array of boxes
                   CBox(8.0, 5.0, 2.0),     // Initialize the boxes...
                   CBox(5.0, 4.0, 6.0),
                   CBox(4.0, 3.0, 3.0)
                 };
        
  // Create the CSamples object to hold CBox objects
  CSamples<CBox> myBoxes(boxes, _countof(boxes));
        
  CBox maxBox = myBoxes.Max();              // Get the biggest box
  cout << endl                              // and output its volume
       << "The biggest box has a volume of "
       << maxBox.Volume()
       << endl  << endl;

  CSamples<CBox> moreBoxes(CBox(8.0, 5.0, 2.0));
  moreBoxes.Add(CBox(5.0, 4.0, 6.0));
  moreBoxes.Add(CBox(4.0, 3.0, 3.0));
  cout << "The biggest box has a volume of "
       << moreBoxes.Max().Volume()
       << endl;
  return 0;
}

On line 125 and 142 there is a constructor and add operator using move semantics. There is no real advantage to the use like this right, performance wise and its just useless having two that do the exact same thing? The C++ standard says that if you use T& it will still accept rvalues as arguments.

[Anmol444]

Please help!

[cire]

There is no real advantage to the use like this right, performance wise and its just useless having two that do the exact same thing?

Try using CSamples to contain:

class NotCopyable
{
public:
    NotCopyable() {}
    NotCopyable(NotCopyable&&) {}

    void operator=(NotCopyable&&) {}

private:
    NotCopyable(NotCopyable&) ;
    void operator=(NotCopyable&) ;
};

without them. And, of course there is an advantage for types that support move semantics. Moving is usually cheaper than copying.

[Anmol444]

But it isnt moving, its doing the exact same thing as the lvalue one?

[Anmol444]

So whats the need?

[Anmol444]

Atleast here

[cire]

So whats the need?

I believe I just told you. Your container won't work for NotCopyable without the move versions but will with them, and for types that support move operations, move operations are cheaper than (or at the worst equivalent to) copy operations.

Surely you can see that generic containers are meant to work with different types, and presumably you want it to work for as many types as possible and also as efficiently as possible. If not, continue your current line of thinking.

[Anmol444]

As much as I try to understand this I just cant seem to put my finger on it. Why wont my container work for NotCopyable without the move versions?

[Anmol444]

Oh I just facepalmed so hard, I understand why there in the class, for other classes that have move semantics, and not for doubles and ints.

But why wont my container store NotCopyable?

[Anmol444]

I can store it in my container, I just get a warning even if the move is there or not.


This is the output

>------ Build started: Project: Tests, Configuration: Debug Win32 ------
1>  Ex8_10.cpp
1>c:\users\anmol\documents\visual studio 2012\projects\c++ book\code from book\chapter 08\ex8_10.cpp(182): warning C4930: 'CSamples<T> notcopy(NotCopyable)': prototyped function not called (was a variable definition intended?)
1>          with
1>          [
1>              T=NotCopyable
1>          ]
1>  Tests.vcxproj -> C:\Users\Anmol\documents\visual studio 2012\Projects\Tests\Debug\Tests.exe
========== Build: 1 succeeded, 0 failed, 0 up-to-date, 0 skipped ==========

I dont quite understand whats going. Can you please help!

[cire]

You probably did something like:

int main()
{
    CSamples<NotCopyable> nc(NotCopyable());
}

which, as the warning says, is a function prototype. You can fix that by using an extra set of parentheses:

int main()
{
    CSamples<NotCopyable> nc((NotCopyable()));
}

or

int main()
{
    CSamples<NotCopyable> nc = NotCopyable() ;
}

Google: C++ most vexing parse

[Anmol444]

This was what I did

CSamples<NotCopyable> notcopy(NotCopyable)

But ok ill google it. But still why CSamples cant store NotCopyable, what is the reason?

[cire]

If you remove the move versions of the member functions, it does not.

Again, CSamples<NotCopyable>notcopy(NotCopyable) is not an instance of a container holding NotCopyable objects. It is a function declaration/prototype.

[Anmol444]

Your right it doesnt? But why? o.O

Oh thanks for the vexing parse thing just learned something new :D

[Anmol444]

Please help cire!

[Anmol444]

Oh but the reason thats not copyable is cause its set to private lol.

I thought it was something more complex or something xD which is why I missed it.

[cire]

It is a common thing pre-C++11 support to make a copy constructors/copy assignment operators private to disable their use. Iirc, VC++ doesn't support the delete/default specifications for constructors/assignment operators yet, so I'm not in the habit of using them.

[Anmol444]

It does VC++ does except there are no move constructors/assignment operators. Atleast I think. But thanks man!