Problèmes avec les fonctions de constructeur lors de l'écriture de modèles de haute précision à l'aide de structures C++

Question

Confusion sur les opérateurs de surcharge de structure

#include<iostream>
#include<string>
#include<cstring>
#include<cstdio>
using namespace std;
const int N = 1005;
struct bign
{
    int len,s[N];
    bign()  {  memset(s,0,sizeof(s));  len=1;  }
    bign(int num)  {  *this=num; }
    bign(char *num) { *this=num; }
    bign operator =(int num)
    {
        char c[N];
        sprintf(c,"%d",num);
        *this=c;
        return *this;
    }
    bign operator =(const char *num)
    {
        len=strlen(num);
        for (int i=0;i<len;i++) s[i]=num[len-1-i]-'0';
        return *this;
    }
    string str()
    {
        string res="";
        for (int i=0;i<len;i++) res=(char)(s[i]+'0')+res;
        return res;
    }
    void clean()
    {
        while (len>1&&!s[len-1]) len--;
    }
    bign operator +(const bign &b)
    {
        bign c;    
        c.len=0;
        for (int i=0,g=0;g||i<len||i<b.len;i++)
        {
            int x=g;
            if (i<len) x+=s[i];
            if (i<b.len) x+=b.s[i];
            c.s[c.len++]=x%10;
            g=x/10;
        }
        return c;
    }
    bign operator -(const bign &b)
    {
        bign c;
        c.len=0;
        int x;     
        for (int i=0,g=0;i<len;i++)
        {
            x=s[i]-g;
            if (i<b.len) x-=b.s[i];
            if (x>=0) g=0;
            else{          
                x+=10;
                g=1;
            };
            c.s[c.len++]=x;
        }
        c.clean();
        return c;
    }
    bign operator *(const bign &b)
    {
        bign c;
        c.len=len+b.len;
        for (int i=0;i<len;i++) for (int j=0;j<b.len;j++) c.s[i+j]+=s[i]*b.s[j];
        for (int i=0;i<c.len-1;i++) { c.s[i+1]+=c.s[i]/10; c.s[i]%=10; }
        c.clean();
        return c;  
    }
    bool operator <(const bign &b)
    {
        if (len!=b.len) return len<b.len;
        for (int i=len-1;i>=0;i--)
             if (s[i]!=b.s[i]) return s[i]<b.s[i];
        return false;
    }
    bign operator +=(const bign &b)
    {
        *this=*this+b;
        return *this;
    }
    bign operator -=(const bign &b)
    {
        *this=*this-b;
        return *this;
    }  
};
istream& operator >>(istream &in,bign &x)
{
  string s;
  in>>s;
  x=s.c_str();
  return in;
}
ostream& operator <<(ostream &out,bign &x)
{
    out<<x.str();
    return out;
}
int main(){
    bign a,b,c;
    ios::sync_with_stdio(false);
    cin>>a>>b;
//    cout<<a<<endl;
//    cout<<b<<endl;
    c=a+b;
    cout<<c<<endl;
    return 0;
}

dans

bign(int num)  {  *this=num; }
bign(char *num) { *this=num; }

Quelle est la fonction ?
Si vous supprimez ces deux instructions, la compilation peut toujours se dérouler normalement mais

bign n=123;

compilera les erreurs, mais

bign n;
n=123;

Il peut être compilé normalement
L'initialisation de la structure ne devrait pas être
bign n(123);
Un novice l'a essayé et a constaté que les résultats ne sont pas différents
Espoir d'aide

.

Answer 1

Citation d'un article : http://www.cnblogs.com/chio/a…. L'affectation s'effectue entre deux objets existants, tandis que l'initialisation consiste à créer un nouvel objet, et sa valeur initiale provient d'un autre objet existant. Le compilateur fera la distinction entre ces deux situations, en appelant l'opérateur d'affectation surchargé lors de l'affectation et en appelant le constructeur de copie lors de l'initialisation. S'il n'y a pas de constructeur de copie dans la classe, le compilateur en fournira un par défaut. Ce constructeur de copie par défaut copie simplement chaque membre de la classe.

bign n=123;

Le constructeur de copie s'appelle :

bign(int num)  {  *this=num; }

Bien sûr, vous ferez une erreur après avoir commenté, et

bign n;
n=123;

Le constructeur par défaut est appelé en premier, puis l'opérateur d'affectation est appelé, il n'y a donc rien de mal après avoir commenté les deux fonctions.

Vous pouvez le déboguer vous-même.