Program received signal SIGSEGV, Segmentation fault.

[pu4koff]

to vvviperrr: это работает? Если да, то на каком компиляторе?)
to ciaonataha: Это же не тот код, который Вы компилите. Дебаггер ругается сначала на: newt::fmin а в приведённом Вами коде я этой функции не наблюдаю

[ciaonataha]

когда добавляу адрес:

nt.nrfuncv =&interface::equilibre_Fe_Cr_C;

то компилируется,
но дебагер выдает опять эту ошибку:

Program received signal SIGSEGV, Segmentation fault.
[Switching to Thread -1211889984 (LWP 9785)]
0x080499f9 in newt::fmin (this=0xbff0b8fc, x=@0xbff0b928) at newt.cpp:120
120       ((interface*)this->*nrfuncv)(GetN(), x, fvec);

[ciaonataha]

class newt

{
private:
  double fmin(std::vector <double> &x);
  void lnsrch(int n, std::vector <double> &xold, double fold, std::vector <double> &g, std::vector <double> &p, std::vector <double> &x,double *f, double stpmax, int *check); 
  void echange(double &a,double &b) const;
public:
//  interface *func;
//  interface *jacobian;
//  sortie *print;
  void (interface::*nrfuncv)(int nn, std::vector <double> &v, std::vector <double> &f);
  void (interface::*jacobfunc)(std::vector <double> &, std::vector <double> &, std::vector < std::vector<double> > &);

  void (sortie::*on_subproduct)();//Function of a conclusion of intermediate results
public:
  int nn;
  std::vector <double> fvec;
  newt() //Konstruktor
  {
    on_subproduct = NULL; //By default intermediate results are not deduced
  }

  unsigned int GetN() const {return nn;};
  void calc(std::vector <double> &x, int *check); //Newton
};

#include "newt.h"


double newt::fmin(std::vector <double> &x)
{
  int i;
  double sum;
  //(func->*nrfuncv)(GetN(), x, fvec);
  ((interface*)this->*nrfuncv)(GetN(), x, fvec);
  for (sum = 0.0, i = 0; i < nn; ++i)
    sum += fvec[i]*fvec[i];
  return 0.5*sum;

}


void newt::calc(std::vector <double> &x, int *check)

{
  FILE *fp = fopen("sortie.txt","w");
  std::vector <double> g(nn), xold(nn);
  fvec.resize(nn);

  double fold, F = fmin(x);

  double sum = 0;

  for (int i = 0; i < nn; ++i)

  sum += SQRnewt(x[i]);

  double stpmax = STPMXnewt*FMAXnewt(sqrt(sum), (double)nn);
  std::vector <double> f(nn);
  try

  {

    while (true)

    {
//      (func->*nrfuncv)(nn, x, f);
     ((interface*)this->*nrfuncv)(GetN(), x, fvec);
      std::vector < std::vector<double> > J(nn);
      for(int i = 0 ; i < J.size() ; i++)
      {
       J[i].resize(nn);
      } 
//      (jacobian->*jacobfunc)(x,f,J);

      ((interface*)this->*jacobfunc)(x,f,J); 
      for (int i = 0; i < J.size(); ++i)
      {
        sum = 0;
        for (int j=0; j < J[i].size(); ++j)
          sum +=J[j][i]*fvec[j];
        g[i] = sum;
      }
      Inverse(J); //Inverse matrice Jacobian
      std::vector <double> dx(nn);

      int indice = 0;
      for (int k = 0; k < nn; ++k)
       {
        dx[indice]=0.0;
        for (int l = 0; l < nn; ++l)
           dx[l] += (-1.) * J[k][l] * f[l];
           indice++; 
       }
      fold = F;
      for (int i = 0; i < nn; ++i)
      xold[i] = x[i];
      lnsrch(nn, xold, fold, g, dx, x, &F, stpmax, check);

/************************************************************************************************************/
    if (on_subproduct) //If it is necessary to deduce results 
      ((sortie*)this->*on_subproduct)(); //it is deduced


     double test = 0;
     for (int i = 0; i < nn; ++i)
       if (fabs(fvec[i]) > test)
         test = fabs(fvec[i]);
     if (test < epsilonnewt)
       break;

     double norm = norme2(dx); //We consider norm

     if (norm < epsilonnewt) //If < eps 
       break; //We leave
    }

  }

  catch (ErreurMatrice &a)

  {

    printf("Errore!!!"); //If there was an error

    *check = 1;

    return;

  }
  fclose(fp);

  *check = 0;

}
}

[vvviperrr]

клево мы нашли баг студии студия 2003 это схватывает, у меня отрабатывает) можешь воспользоваться первым способом, он точно правильный. остальное - вечером, как приду домой

[vvviperrr]

2pu4koff это работает на 2003 студии)) очередная бага, или "фича"

[pu4koff]

Уберите этот и аналогичный

((interface*)this->*nrfuncv)(GetN(), x, fvec);

ужас и верните как было, т.к. это 100% неправильно, а то 100% правильно было
Перед вызовом: (func->*nrfuncv)(GetN(), x, fvec);
Вы точно инициализируете значение func и nrfuncv?

[pu4koff]

Сообщение от vvviperrr

2pu4koff это работает на 2003 студии)) очередная бага, или "фича"

Интересно как это может работать...
При вызове ((interface*)this->*nrfuncv)(GetN(), x, fvec); из класса newt мы творим чудеса
Допустим, interface - окно, newt - дом и мы утверждаем, что дом - это окно и еще что-то с этим "псевдоокном" делаем. Так ведь можно открывая таким образом окно и дом взорвать, если указатели "правильно" лягут

[vvviperrr]

да, я конечно тут ступил, не посмотрел на вывод дебага и стал ковырять код уже потом начало доходить, какой тут может быть адрес без объекта или без статичной функции. Но факт налицо, студия это дело собирает, и даже отладчиком можно зайти в этот всевдо-указатель на функцию.

[ciaonataha]

class newt
{
public: 
  interface *func;
  interface *jacobian;
  sortie *print;
  void (interface::*nrfuncv)(int nn, std::vector <double> &v, std::vector <double> &f);
  void (interface::*jacobfunc)(std::vector <double> &, std::vector <double> &, std::vector < std::vector<double> > &);

  void (sortie::*on_subproduct)();//Function of a conclusion of intermediate results
public:
  int nn;
  std::vector <double> fvec;
  newt() //Konstruktor
  {
    on_subproduct = NULL; //By default intermediate results are not deduced
  }

newt.cpp

double newt::fmin(std::vector <double> &x)
{

  int i;

  double sum;

  (func->*nrfuncv)(GetN(), x, fvec);//ошибка здесь

  for (sum = 0.0, i = 0; i < nn; ++i)

    sum += fvec[i]*fvec[i];

  return 0.5*sum;

}

void newt::calc(std::vector <double> &x, int *check)

{  FILE *fp = fopen("sortie.txt","w");
  std::vector <double> g(nn), xold(nn);
  fvec.resize(nn);
  printf("here1\n");

  double fold, F = fmin(x);

  double sum = 0;

  for (int i = 0; i < nn; ++i)

  sum += SQRnewt(x[i]);

  double stpmax = STPMXnewt*FMAXnewt(sqrt(sum), (double)nn);
  std::vector <double> f(nn);
  try

  {

    while (true)

    {
      (func->*nrfuncv)(nn, x, f); //ошибка здесь
      std::vector < std::vector<double> > J(nn);
      for(int i = 0 ; i < J.size() ; i++)
      {
       J[i].resize(nn);
      } 
      (jacobian->*jacobfunc)(x,f,J);

      for (int i = 0; i < J.size(); ++i)
      {
        sum = 0;
        for (int j=0; j < J[i].size(); ++j)
          sum +=J[j][i]*fvec[j];
        g[i] = sum;
      }
      Inverse(J); //Inverse matrice Jacobian
      std::vector <double> dx(nn);

      int indice = 0;
      for (int k = 0; k < nn; ++k)
       {
        dx[indice]=0.0;
        for (int l = 0; l < nn; ++l)
           dx[l] += (-1.) * J[k][l] * f[l];
           indice++; 
       }
      fold = F;
      for (int i = 0; i < nn; ++i)
      xold[i] = x[i];
      lnsrch(nn, xold, fold, g, dx, x, &F, stpmax, check);

/************************************************************************************************************/
    if (on_subproduct) //If it is necessary to deduce results 
     (print->*on_subproduct)(); //it is deduced

     double test = 0;
     for (int i = 0; i < nn; ++i)
       if (fabs(fvec[i]) > test)
         test = fabs(fvec[i]);
     if (test < epsilonnewt)
       break;

     double norm = norme2(dx); //We consider norm

     if (norm < epsilonnewt) //If < eps 
       break; //We leave
    }

  }

  catch (ErreurMatrice &a)

  {

    printf("Errore!!!"); //If there was an error
    fclose(fp); 

    *check = 1;

    return;

  }
  fclose(fp);

  *check = 0;

}

[ciaonataha]

main.cpp

#include "donnees.cpp"
#include "phase.cpp"
#include <ncurses.h>
#include "newt.cpp"
#include "erreurMatrice.cpp"


char fichiersortie[20];
segment seg[20];
int nbseg;
chargement ch;
sortie so;

matrice mat;

site_homogene_constant site_cem(&mat);
site_homogene_constant site_eps(&mat);

distribution_moyenne<sphere> cem(&site_cem);
distribution_moyenne<sphere> eps(&site_eps);

double temps,dt;
double T,dT;

int main()
{
mat.Thermo = new Gibbs("ferrite.txt");//Fe-Cr-C
cem.classe0->Thermo = new Gibbs("cementite.txt");//Fe-Cr-C
newt nt;
phase *matrice;
interface mv;
interface pf;


  ch.ouverture("param.txt");
  ch.lecture();
  ch.fermeture();
  so.ouverture(fichiersortie);//so.ouverture("sortie.txt");

    for(int iterseg=1;iterseg<=nbseg;iterseg++)
      {
        temps=seg[iterseg].date;
        dt=(seg[iterseg+1].date-temps)/seg[iterseg+1].pas;
      
        T=seg[iterseg].temperature;
        dT= dt * (seg[iterseg+1].temperature-seg[iterseg].temperature)
	/ (seg[iterseg+1].date-seg[iterseg].date);
      
        while(temps<seg[iterseg+1].date)
	 {
	  temps+=dt;
	  T+=dT;
//===========Newton-Raphson======
        nt.nn = 9;
        std::vector <double> Y(nt.nn);
        nt.fvec.resize(nt.nn);
        int check = 0;
        int i=1;
        while(matrice->frontiere[i]!=NULL)
         {
          nt.func = &mv;
          nt.nrfuncv = &interface::equilibre_Fe_Cr_C;
          nt.jacobian = &pf;
          nt.jacobfunc = &interface::Jacobian;
          i++;
         }
//==Thermo====
        mat.Thermo->read(T);
        cem.classe0->Thermo->read(T);
        Y[0] = mat.Thermo->y1[0];
        Y[1] = mat.Thermo->y1[1];
        Y[2] = mat.Thermo->y2[0];
        Y[3] = mat.Thermo->y2[1];
        Y[4] = cem.classe0->Thermo->y1[0];
        Y[5] = cem.classe0->Thermo->y1[1];
        Y[6] = cem.classe0->Thermo->y2[0];
        Y[7] = cem.classe0->Thermo->y2[1];
        Y[8] = nf;
//============
//        so.ecriture();
//        nt.print = &so;
        nt.on_subproduct = &sortie::ecriture; 
        nt.calc(Y, &check);
//        Y.clear();   
	 } 
      }
  so.fermeture();

  return(0);
}