Question

我在移动我的结构时遇到了一些麻烦而没有重写它，

typedef struct listaC {
int coluna;
float valor;
struct listaC *prox;
} *Colunas;

typedef struct listaL {
    int linha;
    Colunas lcol;
struct listaL *prox;
} *Mat;

在我的功能中我试图添加2 Matrix

void addTo (Mat *m1, Mat m2){
    if(m2==NULL) return;
    if(m1==NULL) m1 = &m2;
    while(*m1!=NULL)
    {
        while((*m1)->lcol!=NULL)
        (*m1)->lcol->valor += m2->lcol->valor;
        m2->lcol=m2->lcol->prox;
    //here  m1->lcol = &((*m1)->lcol->prox);
    }
    m2 =m2->prox;
    m1 = &((*m1)->prox);
    *m1 = *m1->prox;
}

但我在

收到错误

m1->lcol = &((*m1)->lcol->prox);

错误：请求成员'lcol'不是结构或联合 m1-＆gt; lcol =＆amp;（（* m1） - ＆gt; lcol-＆gt; prox）;

我该如何解决这个问题？

Answer 1

m1是指向Mat的指针，因此是指向struct的指针。分配的右侧是正确的，但左侧缺乏解除引用：

(*m1)->lcol = (*m1)->lcol->prox;

我还从右侧删除了&获取地址，因为prox已经是指针。

Answer 2

有关

m1->lcol = &((*m1)->lcol->prox);

对于左侧，m1是指向指针的指针。要使用 - ＆gt;你需要成为一个指针。

(*m1)->lcol

另外在右侧＆amp;当你想要just指针本身时，它会成为指向prox的指针的地址。

(*m1)->lcol = ((*m1)->lcol->prox);

在其他方面，while（* m1！= NULL）是一个无限循环，因为m1永远不会让你进入循环中的一个

Answer 3

语法中增加的复杂性使您忘记在作业的左侧取消引用变量m1。

m1->lcol = &((*m1)->lcol->prox);      // causes the error m1 is a ListaL**
(*m1)->lcol = &((*m1)->lcol->prox);   // this should compile.

另外，我想我在这行代码中发现了一个错误。由于m1是一个链表，并且add不会改变行和列的顺序，只改变它们的内容，不会改变链接指针的任何内容会引入错误吗？

// this would make add look something like this:

// void add(Mat *m1, Mat m2)  why the added * complexity.
void add(Mat m1, Mat m2)
{
  struct listaL* proxL1;
  struct listaL* proxL2;
  struct listaC* proxC1;
  struct listaC* proxC2;

  if(m2==NULL) return;
  //if(m1==NULL) m1 = &m2; // Appropriate here?  Is this the right 
                           // place to do this?  Not part of add
                           // definition.. no return, so effect is 
                           // *m1 = m2 = 2.m2 
                           // you should consider simply passing a Mat
                           // and checking for NULL
  if (m1 == NULL) return; 

  for (proxL1 = m1, proxL2 = m2; 
       proxL1 != 0 && proxL2 != 0; 
       proxL1 = proxL1->prox, proxL2 = proxL2->prox)
  {
    for (proxC1 = proxL1->lcol, proxC2 = proxL2->lcol;
         proxC1 != 0  && proxC2 != 0; 
         proxC1 = proxC1->prox, proxC2 = proxC2->prox)
    {
      proxC1->valor += proxC2->valor;
    }
  }
  // values have been added.... done!  
}

我认为你应该只是在一个美好的夜晚睡觉和浓咖啡后的早晨尝试乘法：）

提示：也许链表不是Matrices的最佳选择，而一个简单的malloc＆lt; strike> double float数组可以解决这个问题吗？

这样的事情会更容易处理，不是吗？

typedef struct Mat 
{
  int rows;
  int cols;
  float data[1];
};
// useful for random access
#define MAT_AT(m, r, c) ((m)->data + ((r) * (m)->cols) + (c))
// useful for malloc, copy
#define MAT_SIZEOF(r, c) (sizeof(struct Mat) + (sizeof(float) * (((r) * (c)) - 1)))

// makes for an api that is much faster and efficient

struct Mat* matalloc(int r, int c)
{
  struct Mat* m = (struct Mat*)malloc(MAT_SIZEOF(r, c));
  if (m == 0) return 0;
  m->rows = r;
  m->cols = c;
  memset(m->data, 0, sizeof(float) * r * c); 
  return m
}

void matfree(struct Mat* m)
{
  free(m);
}

struct Mat* matadd(struct Mat* r, struct Mat* a, struct Mat* b)
{
  int i, j;
  assert(a && b && r 
         && a->rows == b->rows && a->cols == b->cols 
         && a->rows == r->rows && a->cols == r->cols);
  for (i = 0; i < a->rows; ++i)
    for (j = 0; j < a->cols; ++j)
      *MAT_AT(r, i, j) = *MAT_AT(a, i, j) + *MAT_AT(b, i, j);
  return r;
}

struct Mat* mataddto(struct Mat* r, struct Mat* a)
{
  return matadd(r, r, a);
}

结构指针参数

3 个答案: