Falha de segmentação

Olá!! Estou tendo problemas com falha de segmentação. Tenho um programa principal e uma classe externa a qual chamo na principal. O erro ocorre na função que retorna um número complexo, mas não é ponteiro.
Segue o programa:

[code]#ifndef MT1D_H
#define MT1D_H

#include <complex.h>
#include
#include
#include
#include <stdlib.h>
//#include // Para usar o switch.

using namespace std;

class mt1d
{
public:
mt1d(int n, double *resist, double *iz, double freq, double *mu);
double complex FTE(int cnt); // Calculo do fator de estratificacao para o modo TE.

private:
int N;
double *RES;
double *IZ;
double FREQ;
double *MU;

  	  double RES_R;                  // Resistividade de referencia.
      double SKIN;

      double complex a, th, znum;    // TANGH.
      double complex Znumber, Ze;    // Rcexp.
      int cnt;                       // Uk |FTE |FTM. contador.
      double complex U_cnst;         // Uk.
      double h;                      // FTE | FTM. espessura da camada.
      double complex FTEo;           // FTE. fator de estratificacao do modo TE.
      //int ij;

      double complex TANGH(double complex znum);      // Calculo da tangente hiperbolica complexa.
      double complex Rcexp(double complex Znumber);   // Redefinicao para obter a exponencial complexa.
      double complex Uk(int cnt);                     // Calculo da constante de propagacao.

};

#endif

#include “MT1D.h”
#define m0 1
#define PI 3.141592653589793 // Valor da constante PI.
#define mu0 4.0PI1.e-7 // Valor da permeabilidade magnetica do vacuo.
#define enep 2.718281828459046 // Valor do e neperiano.

// O valor do campo Ez e nulo, pois a variavel lambda e zero. Onda plana horizontal.

mt1d :: mt1d (int n, double *resist, double *iz, double freq, double *mu)
{
N = n; // Numero de camadas do modelo.
RES = resist; // Vetor das resistividades.
IZ = iz; // Vetor das interfaces.
FREQ = freq; // Valor unico, passado em cada chamada da funcao para calculo do skin depth.
MU = mu; // Vetor de permeabilidades magneticas das camadas.

 RES_R = RES[1];                // Resistividade de referencia, adotado como sendo da primeira camada. Em geral, a primeira camada abaixo da interface de medidas do campo.

 SKIN = ( 500 * sqrt(10 * RES_R /FREQ) ) / PI;      // Calculo do Skin depth, que sera visivel a todas as funcoes desta classe.

}
//=============================================================================================================================================
double complex mt1d::FTE (int cnt) // Calculo do fator de estratificacao para o modo TE.
{
FTEo = 1.0 + 0.0*I;

if (cnt == N){
exit(1);
}
else
{
for (int ij = N-2; ij <= cnt; ij–)
{
h = (IZ[ij] - IZ[ij-1])/SKIN;
FTEo = (FTEo * Uk(ij+1) * MU[ij] + Uk(ij)*MU[ij+1]TANGH(hUk(ij)) ) / ( Uk(ij)MU[ij+1] + FTEoUk(ij+1)*MU[ij]TANGH(hUk(ij)) );
//cout << cnt << " " << N << endl;
}
}

return FTEo;

}
//=============================================================================================================================================
double complex mt1d::Uk(int cnt) // Calculo da constante de propagacao.
{
U_cnst = 0.0 + 0.0I;
if(cnt == 0)
{
U_cnst = (1.0 + 1.0
I)*csqrt(MU[0]RES_R/RES[0]);
}
else
{
U_cnst = (1.0 + 1.0
I)*csqrt(MU[cnt]*RES_R/RES[cnt]);
}

return U_cnst;
}
//=============================================================================================================================================
double complex mt1d::Rcexp(double complex Znumber) // Redefinicao para obter a exponencial complexa.
{
if(creal(Znumber) > -40.0)
{ Ze = cexp(Znumber); }
else
{ Ze = 0.0 + 0.0*I; }

return Ze;
}
//=============================================================================================================================================
double complex mt1d::TANGH(double complex znum) // Calculo da tangente hiperbolica complexa.
{ // double complex a =num1 + num2I;
a = cexp(-2
znum); // cout << "a = " << a << endl;
th= (1 - a)/(1 + a); // Definicao da funcao: TANGH.

return th;
}[/code]

Parece que ele não lê o if …else da última função: FTE.

Tem certeza que esse for está certo?

Se cnt for a quantidade de elementos dentro do seu array, esse código nunca irá parar.

Se está dando segmentation fault, com certeza você está acessando um índice errado do array.

PS: Você vai ter muita dor de cabeça se continuar programando C++ como se fazia nos anos 80. Por que não usa recursos da linguagem como referências, ou a classe std::array?
http://www.cplusplus.com/reference/array/array/

Ou mesmo a classe std::complex?
http://en.cppreference.com/w/cpp/numeric/complex

Além disso, faz tempo que o uso de define não é recomendado. Considere usar consts.

Bom, é que ainda sou nova na programação em c++.
Até agora eu só tinha programado em fortran.

Bom, vou tentar melhorar minha programação.

sim, ela acesa a posição de memoria errada, mas ainda assim não sei como consertar o erro. Parece que ele não entra no loop for, como se pulasse todo o for .

vou fazer novas modificações para ver se dá certo.

Obrigada pelas dicas e pela orientação.

Consegui ver o erro, o sinal estava ao contrario!!

Muito obrigada!!!

[quote=Alin]Bom, é que ainda sou nova na programação em c++.
Até agora eu só tinha programado em fortran.

Bom, vou tentar melhorar minha programação.

sim, ela acessa a posição de memoria errada, mas ainda assim não sei como consertar o erro. Parece que ele não entra no loop for, como se pulasse todo o for .

vou fazer novas modificações para ver se dá certo.

Obrigada pelas dicas e pela orientação.

[/quote]

Eu só reforço essa questão pq o C++ é uma linguagem bastante cruel com quem não usar de boas práticas. E boa parte das novidades da linguagem estão em práticas e APIs, não tanto na estrutura da linguagem em si.

Uma boa leitura é o Effective C++, mas como você é nova na linguagem, vai ter que quebrar um pouco a cabeça errando muito antes de conseguir ler esse livro e aproveitá-lo 100%.

Tenho outra duvida, mas agora o erro não é de falha de segmentação. Ela está na linha 79 na definição de FTEo. Parece que o erro está na função Uk(), na segunda chamada com o índice cnt+1. Não é um erro acusado pelo compilador, é mais um erro de lógica, porque sei que a saída é um número complexo não inteiro, porém parece que nada é calculado, e a saída é (1,0).