如何將內存分配給具有數組成員的類的實例？

Question

在我的理解中，在通常情況下，數組在編譯時被分配內存，但是當數組是一個成員變量時會發生什麼，在編譯過程中幾乎沒有任何東西可以分配內存。是否在創建該類的實例時被隱式動態分配？

class Arr{ 
    public: 
    int arr[10]; 
}; 

Arr doSomething(Arr &arg){ 
    return arg; //copy of arg created; 'copy=new int[10]' at this point? 
} 

int main(){ 
    Arr temp; 
    doSomething(temp); 

    //if returned object's array was dynamically initialized 
    //will it result the array in temp being released twice? 
} 

UPD。在我的情況下，當我嘗試將B> A的A-B分解時，情況會上升。在這些情況下，我可以訪問數組來讀取它，但修改它的值會導致垃圾。此外，在main的最終輸出是好的。下面是完整的代碼：

#include <iostream> 

using namespace std; 

const int MAX_ARRAY_SIZE=256; 

char* getOperatorIndex(char* equationString); 
bool isOperator(char characterDec); 
int* toIntArray(char* firstInA, char* lastInA, int* firstInB); 

class Number{ 
    int* firstInNumber; 
    int* lastInNumber; 
    int number[MAX_ARRAY_SIZE]; 

    public: 
    Number(); 
    ~Number(); 
    bool operator<(Number& b); 
    int& operator[](int index); 
    Number operator-(Number& b); 
    void print(); 
    int length(){return lastInNumber-firstInNumber;} 
    int*& lastPtr(){return lastInNumber;} 
    int*& firstPtr(){return firstInNumber;} 
}; 

Number::Number(){ 
    firstInNumber=number; 
    lastInNumber=number; 
} 

Number::~Number(){ 
    cout<<"number destroyed"<<endl; 
} 

int& Number::operator[](int index){ 
    return number[index]; 
} 

bool Number::operator<(Number& b){ 
    if(length()>b.length())return false; 
    if(length()<b.length())return true; 

    for(int a=0;a<length();++a){ 
     if(number[a]>b[a])return false; 
     if(number[a]<b[a])return true; 
    } 
    return false; 

} 

void Number::print(){ 
    for(int a=0; a<=length(); ++a){ 
     cout<<number[a]; 
    } 
    cout<<endl; 
} 

Number Number::operator-(Number& b){ 

    Number result; 

    if(*this < b) 
    { 
     result=b-*this; 
     cout<<*result.lastPtr()<<endl; 
     result.print(); 
     *result.lastPtr()*=-1; // GARBAGE HERE 
     cout<<*result.lastPtr()<<endl; 
     return result; 
    } 

    result[0]=0; 

    for(int q=0; q<=length(); ++q) 
    { 

     if(b.length()-q >= 0) 
     { 
      result[q]+=(*this)[length()-q]-b[b.length()-q]; 

      if(result[q] < 0) 
      { 
       result[q]+=10; 
       result[q+1]=-1; 

      } 
      else 
      { 
       result[q+1]=0; 
      } 

     } 
     else 
     { 
      result[q]+=(*this)[length()-q]; 

     } 

    ++result.lastPtr(); 
    } 

    do{ 
     --result.lastPtr(); 
    }while(!*result.lastPtr()); 

    return result; 
} 

int main(){ 
    char equationArray[MAX_ARRAY_SIZE*2+1]; // operandA(<=256) operator(1) operandB(<=256) 
    Number a,b; 

    cin>>equationArray; 
    char* operatorPtr=getOperatorIndex(equationArray); 

    a.lastPtr()=toIntArray(equationArray, operatorPtr, a.firstPtr()); 
    b.lastPtr()=toIntArray(operatorPtr+1, operatorPtr+strlen(operatorPtr), b.firstPtr()); 

    a.print(); 
    b.print(); 

    Number c; 
    switch(*operatorPtr){ 
     case '-': 
      c=a-b; 
      break; 
    } 
    c.print(); 

} 


char* getOperatorIndex(char* equationString){ 
    while(!isOperator(*++equationString)); 
    return equationString; 
} 

bool isOperator(char characterDec){ 
    if(characterDec>='*' & characterDec<='/')return true; 
    return false; 
} 


int* toIntArray(char* firstInA, char* lastInA, int* firstInB){ 
    while(lastInA-firstInA>0){ 
     *firstInB=*firstInA-'0'; 
     ++firstInB; 
     ++firstInA; 
    } 
    return --firstInB; 
} 

Answer 1

一類的所有數據成員具有相同存儲時間作爲創建類的對象。因此，在：

int main(){ 
    Arr temp; 
    doSomething(temp); 
} 

它的類型的數據成員temp.arrint[10];還具有自動存儲持續時間 ..（或什麼是不適當稱爲 「堆棧對象」）

---

Arr doSomething(Arr &arg){ 
    return arg; //copy of arg created; 'copy=new int[10]' at this point? 
} 

不，這裏沒有堆分配。而不是隱式拷貝構造函數的成員智能副本。請參閱How are C++ array members handled in copy control functions?