problem using accumulate()

[evanescence]

Hi , when I try to run my program an error message appears:

Error	1	error C2440: 'initializing' : cannot convert from 'int (__cdecl *)(CDigit *&,CDigit *&)' to 'int'	e:\my_project\my_project\s.cpp	307	my_project

I guess the problem is in the way I use the accumulate() function , because when I remove the 4 lines where it's used, the error message disappears.

Here's the code:

#include<iostream>
#include<string>
#include<fstream>
#include<iterator>
#include<list>
#include<algorithm>
#include<functional>
#include<numeric>
#include<cmath>

using namespace std;



 class CDigit
{
	private:
	 int m_iDigit; 
	public: 
	 int GetDigit() const;
	 void SetDigit(const int val);

	 virtual void Output(ostream& toStream)
	 {
		 toStream<<GetDigit()<<endl; }

};



int CDigit::GetDigit() const
{
	return m_iDigit; }


void CDigit::SetDigit(const int val)
{ 
	m_iDigit=val; }








class CExpected : virtual public CDigit
{
private:
	int m_iExpFreq;
public:
	CExpected();
	CExpected(const int val);
	CExpected( const CExpected &obj);
    int GetExpected() const;
	void SetExpected( const int val);

	void Output(ostream& toStream) const
	{
		toStream<<GetExpected()<<endl; }

	virtual void less(const CDigit* pDigit)  const
	{
		if((pDigit ->GetDigit()) > m_iExpFreq) cout<<"1>2"<<endl;
		else if((pDigit ->GetDigit()) < m_iExpFreq) cout<<"1<2"<<endl;
		else if((pDigit ->GetDigit()) == m_iExpFreq) cout<<"1=2"<<endl;

	}

	
	friend ostream& operator<< (ostream& toStream, const CExpected &obj);
	friend istream& operator>> (istream& fromStream, CExpected &obj);
	int operator = (const CExpected &ravno);
	bool operator == (const CExpected &ednakvo) const;
};



CExpected::CExpected()
{
	m_iExpFreq = 0; }


CExpected::CExpected(const int val)
{
	m_iExpFreq = val; }


CExpected::CExpected( const CExpected &obj)
{
	m_iExpFreq = obj.GetExpected();
  }



int CExpected::GetExpected() const
{
	return m_iExpFreq; }


void CExpected::SetExpected( const int val)
{
	m_iExpFreq = val; }




ostream& operator<< (ostream& toStream, const CExpected &obj)
{
	toStream<<obj.GetExpected()<<endl;
	return toStream; }


istream& operator>> (istream& fromStream, CExpected &obj)
{
	int val;

	fromStream>>val;
	obj.SetExpected(val);

	return fromStream;  }


int CExpected::operator = (const CExpected &ravno)
{
	m_iExpFreq = ravno.m_iExpFreq;
	return 0; }


bool CExpected::operator == (const CExpected &ednakvo) const
{
	return (m_iExpFreq == ednakvo.GetExpected()); }





class CObserved : virtual public CDigit
{
private:
	int m_iObsFreq;      
public:
	CObserved();
	CObserved(const int val);
	CObserved( const CObserved &);
	int GetObserved(void) const;
	void SetObserved( const int val);

	void Output(ostream& toStream) const
	{
		toStream<<GetObserved()<<endl;  }


	void  less(CDigit* pDigit) const
	{
		if((pDigit ->GetDigit()) > m_iObsFreq) cout<<"1>2"<<endl;
		if((pDigit ->GetDigit()) < m_iObsFreq) cout<<"1<2"<<endl;
		if((pDigit ->GetDigit()) == m_iObsFreq) cout<<"1==2"<<endl;
	}


	friend ostream& operator<< (ostream& toStream, const CObserved &obj);
	friend istream& operator>> (istream& fromStream, CObserved &obj);
	int operator = (const CObserved &ravno);
	bool operator == (const CObserved &ednakvo) const;
};



CObserved::CObserved()
{
	m_iObsFreq = 0; }


CObserved::CObserved(const int val)
{
	m_iObsFreq = val; }


CObserved::CObserved( const CObserved &obj)
{
	m_iObsFreq = obj.GetObserved(); }



int CObserved::GetObserved(void) const
{
	return m_iObsFreq; }


void CObserved::SetObserved( const int val)
{
	m_iObsFreq = val; }



ostream& operator<< (ostream& toStream, const CObserved &obj)
{
	toStream<<obj.GetObserved()<<endl;
	return toStream; 
}


istream& operator>> (istream& fromStream, CObserved &obj)
{
	int val;
	fromStream>>val;
	obj.SetObserved(val);
	return fromStream;      }



int CObserved::operator = (const CObserved &ravno)
{
	m_iObsFreq = ravno.GetObserved();
	return 0;
 }



bool CObserved::operator == (const CObserved &ednakvo) const
{
	return(m_iObsFreq == ednakvo.GetObserved());  }






class CGoodnessOfFit : public CExpected, public CObserved
{

private:
 	list<CDigit*> m_lData; 
 	list<CDigit*> m_lObs; 
 	int m_iTotalFreqDiff; 
  double m_dChiCalc; 
  double m_dChiAlpha; 

public:

	CGoodnessOfFit(const char* strFileNameExp, const char* strFileNameObs);
	bool calcTotalFreqDiff() ;        
	void SetChiAlpha(double ChiValue) ;     
	bool CalcChi();
	bool CalcGofF() const ;   
	void setData( const int iDigit, const int iExpected, const int iObserved);
	void getData( double& dChiCalc, double& dChiAlpha) const;
	void writeToCout();                          
	bool isFoundExpNumber( const int& iToFind );       
	int GetTotalFreqDiff(); 
	friend istream& operator>> (istream& fromStream, CDigit* &obj);
};








CGoodnessOfFit::CGoodnessOfFit(const char* strFileNameExp, const char* strFileNameObs)
{

	ifstream iStream(strFileNameExp);

	if(iStream.good())
	   {

		copy (istream_iterator<CDigit*>(iStream), istream_iterator<CDigit*> (),          
			back_inserter(m_lData) );  
	}



	ifstream iStream1(strFileNameObs);

	if(iStream1.good())
	   {

		copy (istream_iterator<CDigit*>(iStream), istream_iterator<CDigit*> (),          
			back_inserter(m_lObs) );  
	}
}




bool CGoodnessOfFit::calcTotalFreqDiff()
{
	m_iTotalFreqDiff = GetTotalFreqDiff();
	return true;
}



int sbor(class CDigit* &ob, class CDigit* &ob1)
{
	return ( ob->GetDigit()  + ob1->GetDigit() );  }




bool CGoodnessOfFit::CalcChi()
{
	int Oi = accumulate(m_lObs.begin(), m_lObs.end(), sbor);
	int Ei = accumulate(m_lData.begin(), m_lData.end(), sbor);

	m_dChiCalc = sqrt(((Oi - Ei)^2)/Ei) ; 

	if(m_dChiCalc) return true;
	else return false;
}



void CGoodnessOfFit::SetChiAlpha(double ChiValue)
{
	m_dChiAlpha = ChiValue;  }




bool CGoodnessOfFit::CalcGofF()	const
{
	if( m_dChiCalc < m_dChiAlpha ) return true;
	   else return false;
}



void CGoodnessOfFit::setData( const int iDigit, const int iExpected, const int iObserved)
{
	SetDigit(iDigit);
	SetExpected(iExpected);
	SetObserved(iObserved);

} 



void CGoodnessOfFit::getData( double& dChiCalc, double& dChiAlpha) const
{
	cout<<dChiCalc<<" - "<<dChiAlpha<<endl;
}



void CGoodnessOfFit::writeToCout()
{
	cout<<m_iTotalFreqDiff<<endl;
	cout<<calcTotalFreqDiff()<<endl;
	cout<<CalcChi()<<endl;
	cout<<CalcGofF()<<endl;

}




class Search 
{
private:
	 int iToFind_val;
public:
 
  Search( int val) {
    iToFind_val = val;
  }


    bool operator () ( CDigit* &pointer ) const
	{
      return (pointer -> GetDigit() == iToFind_val) ;
      }
  }; 




bool CGoodnessOfFit::isFoundExpNumber(const int& iToFind ) 
{
	list<CDigit*>::iterator where;
	where = find_if(m_lData.begin(), m_lData.end(), Search(iToFind));

	return true;
}
	


     
int CGoodnessOfFit::GetTotalFreqDiff()
{
	int Exp;
	int Obs;

	Exp = accumulate(m_lData.begin(), m_lData.end(),sbor) ;
	Obs = accumulate(m_lObs.begin(), m_lObs.end(), sbor);

	return( Exp - Obs);  }




istream& operator>> (istream& toStream, CDigit* &obj)
{
	toStream>>obj ;
	return toStream;
}






int main()
{

	cout<<"works"<<endl;
	return 0;

}

Hope you can help me...

[jsmith]

The std::accumulate() overload that takes a binary operator has four parameters:

  template<typename _InputIterator, typename _Tp, typename _BinaryOperation>
    _Tp accumulate(_InputIterator __first, _InputIterator __last, _Tp __init, _BinaryOperation __binary_op)

You have to pass the initial value as the third parameter and the binary function as the fourth.

[evanescence]

thanks, I completely forgot about that. But now it says
Error 1 error C2664: 'int (CDigit *&,CDigit *&)' : cannot convert parameter 1 from 'int' to 'CDigit *&' c:\program files\microsoft visual studio 9.0\vc\include\numeric 45 my_project

I tried changing the function sbor in many ways but the error message is nearly the same evry time.