Red de conocimiento informático - Computadora portátil - c Error de programación, solicite respuestas a los expertos (se pueden complementar). No se pudieron enviar algunas.

c Error de programación, solicite respuestas a los expertos (se pueden complementar). No se pudieron enviar algunas.

En primer lugar, los corchetes de la definición de clase no coinciden, entonces no se pueden inicializar variables miembro no estáticas en la clase.

Si se compila usando VS2005, no se puede encontrar lt;iostream.hgt;, se debe usar lt;iostreamgt; pero VC6.0 debería estar bien.

Al menos se ha modificado el código compilado: (VS2005 compilado)

#includelt;stdlib.hgt;

#includelt;assert.hgt;

p>

Plantilla lt; clase Tgt;

clase mat

{

privada:

int n_;

int m_;

estructura nodo{

T* x_;

nodo* siguiente;

};

p>

nodo *v_;

público:

int i, j;

void init (int N=1, int M=1)

{

afirmar(v_==null

v_=nuevo nodo[N); ];

if (v_==null) exit(0);

nodo* t=v_;

while(ilt;n-1){

t-gt; siguiente= t;

i

}

siguiente=null; >

for (i=0; i lt; N; i ){

v_[i].x_=nueva T[M];

if(v_[i ].x_==null)salir(0 ); }

n_=N

m_=M

}

copia nula(T* v){

int k=0

for ( i=0; ilt; n_*m_; i =m_)

{

for( j=0; jlt; m_; j )v_[k].x_[j]=v[i j]

k

}

}

copia nula(nodo* v){

i=1

hacer{

<; p> for(j=0; jlt; m_;j)v_[i].x_[j]=v-gt;x_[j];

v=v-gt;siguiente;

i;

} while(ilt; n_);

void set(T amp; val)

{

for( j=0; jlt; n_; j )

for(int i=0; ilt; m_; i )

v_[j].x_[i] =val;

}

void destroy(){

T* t

for(int i=0; ilt; n_; i ){

t=v_[i].x_;

eliminar[]t;}

eliminar[]v_;

}

nodo* comenzar()const{ return v_;}

~mat(){

desroy();

}

mat(matlt;Tgt;amp; A) {

init(A.n_, A.m_);

copiar(A. v_);}

mat(int N,i

nt M, nodo * v){

init(N, M

copiar(v)

}

mat); (int N, int M, char* s){

init(N, M);

std::istrstream ins(s);

T * v1=nuevo T[N*M];

for(i=0;ilt;N*M;i)

insgt;gt;v1;

init(N, M);

copiar (v1);

}

matlt; {

if((n_==N)amp; amp; (m_==M))return *this

destruir(); (N, M);

return *this;

}

matlt; amp;

if(v_==A.v_)return *this;

if ((n_===A.n_)amp; amp; (m_===A.m_) ))copiar(A.v_);

else{

destruir();

init(A.n_, A.m_); >

copiar(A.v_);

Devolver *this this

}

}

matlt; amp; operador=(Tamp; escalar){

set(escalar);

return *this

}

int fila; () const{return n_;}

int col() const{return m_;}

amigo istreamamp;gt; (istreamamp; s, matlt; Tgt;amp; A){

int N, M;

sgt; gt; gt;

si ((N! si ((N! = A.n_)||(M! =A.m_)){

A.destroy();

init(N, M);

}

coutlt;lt;"Por favor, ingrese cada número de la matriz directamente"lt;lt;endl;

coutlt;lt;"La primera fila:";

for(i=0;ilt;n_;i){

for(j=0;jlt;m_;j){

cingt;gt;v_[i ].x _[j];

coutlt;lt;'\t';}

coutlt;lt;'\n';

coutlt; lt;'\nth';

coutlt;lt;'\number';

coutlt;lt;'\number';

coutlt;lt; '\número';'\número';'número',\número';

coutlt;lt;número'\num

ber';

coutlt;lt;'número'\número';

coutlt;lt;\número';

for(j=; j; m_;j ){

para(i=0;ilt;n_;i ){

para(j=0;jlt;m_;j )

coutlt;lt;"("lt;lt;i 1lt;lt;","lt;lt;j 1lt;lt;","lt;lt;v _[i].x_[j]lt;lt; ")";

coutlt;lt; '\n';

}

}

amigo operadorlt;lt; (ostreamamp; s, matlt; Tgt.amp; A){

print();

return

}

}

}

};

vacío principal(){}