C++：如何初始化一個使用兩個頭文件的對象？

Question

我在初始化使用兩個頭文件的對象時遇到了問題。一個頭文件將值堆疊到由另一個頭文件構成的數組中。我使用一個單獨的主腳本來執行堆棧定義文件的計算。它看起來如下：

主要腳本

#include <iostream> 
#include "Stack.h" 
#include "Array.h" 

using namespace std ; 

int main() { 

int LEN = 10;    // size array 
double def_val = 1.1 ;  // a default value that is used to fill a resized array 

Stack s(LEN, def_val) ;  // <--- causing compiler error 

// Do calculations with functions defined in a Stack.cc file 

return 0; 
} 

棧頭文件

#ifndef STACK_HH 
#define STACK_HH 

#include <iostream> 
#include "Array.h" 

using namespace std ; 

class Stack { 

    public: 
     Stack(int size, double value) { 
      s.size(size); 
      s.value(value); // <--- Not sure if I should use this, see Array header file how default value is used to resize an array 
      count = 0 

      //used member functions which are not important to solve this particular problem 
     } 

    // Member functions 

    private: 
     Array<double> s ; 
     int count ; 
}; 

陣頭文件

#ifndef ARRAY_HH 
#define ARRAY_HH 

template <class T> 
class Array { 
public: 

    Array(int size, T value) : _size(size) {   // <--- takes two arguments 
    _arr = new T[_size] ; 
    _value = value ;  // Set default value 
    std::cout << "default value = " << _value << std::endl ; 
    } 


    Array(const Array<T>& other) : _size(other._size), _value(other._value) { 
    _arr = new T[other._size] ; 
    _value = _value ;  

    // Copy elements 
    for (int i=0 ; i<_size ; i++) { 
     _arr[i] = other._arr[i] ; 
    } 

    } 

~Array() { 
    delete[] _arr ; 
    } 


    Array<T>& operator=(const Array<T>& other) { 
    if (&other==this) return *this ; 
    if (_size != other._size) { 
     resize(other._size) ; 
    } 
    for (int i=0 ; i<_size ; i++) { 
     _arr[i] = other._arr[i] ; 
    } 
    return *this ; 
    } 

    T& operator[](int index) { 
     if (index > _size) {   
      resize(index) ; 
     } 
     return _arr[index] ; 
    } 

    const T& operator[](int index) const { 
     if (index > _size) {   
     resize(index) ; 
     } 
     return _arr[index] ; 
    } 

int size() const { return _size ; } 
T value() const { return _value ; } // <--- Included this for reading the default value from the object initialized in the main script, just like the size is read. 

void resize(int newSize) { 
    // Allocate new array 
    T* newArr = new T[newSize] ; 

    // Copy elements 
    for (int i=0 ; i<_size ; i++) { 
     newArr[i] = _arr[i] ; 
    } 

    // Fill remaining array with default value 
    for (int i=_size ; i<=newSize; i++){ 
     newArr[i] = _value ; 
    } 

    // Delete old array and install new one 
    delete[] _arr ; 
    _size = newSize ; 
    _arr = newArr ; 

} 


private: 
    int _size ; 
    T* _arr ; 
    T _value ; 
} ; 

#endif 

當編譯我得到的錯誤，沒有匹配功能，可當Stack（int size，double value）{}時，要求爲「Array [double] :: Array（）」 {}正在Stack.h文件中讀取。

最初，只有大小被讀取。但是，我意識到數組頭文件需要第二個參數來創建數組。所以我在類似於s.size（）的Stack.h文件中包含了s.value（）函數。但是這並沒有解決編譯器錯誤。

這是兩週前我已經工作的腳本的修改版本，但現在想擴展它的可用性並將其變爲模板類。

請不要介意我的英語。

編輯：

我謝謝你們倆。這確實造成了這個問題。

Answer 1

這是因爲你沒有指定一個默認的構造函數（Array::Array()）數組和編譯器看到這個的時候：

Stack(int size, double value) { 
     s.size(size); 
     s.value(value); // <--- Not sure if I should use this, see Array header file how default value is used to resize an array 
     count = 0 

     //used member functions which are not important to solve this particular problem 
    } 

你實際上寫的是：

Stack(int size, double value) 
     : s() // default initialize s 
     , count() // default initialize count 
    { 
     s.size(size); 
     s.value(value); // <--- Not sure if I should use this, see Array header file how default value is used to resize an array 
     count = 0 

     //used member functions which are not important to solve this particular problem 
    } 

的s()因爲這是Array的默認構造，並且沒有Array的默認構造函數，所以失敗。

編輯： 作爲hr_117指出的那樣，你可以通過添加一個默認的構造函數，以陣列解決這個問題，或者你可以添加以下初始化堆棧：

Stack(int size, double value) 
     : s(size, value) // default initialize s 
     , count(0) // default initialize count 
    { 
    }