如果你不想直接使用数组，可以考虑使用vector，然后调用push_back函数在末尾添加内容，它会自动调整向量的大小。

#include <iostream>
#include <vector>

int
main() {
    double value;
    std::vector<double> values;

    // Read in values
    while (std::cin >> value) {
        values.push_back(value);
    }

    // Print them back out
    for (std::size_t i(0), len(values.size()); i != len; ++i) {
        std::cout << values[i];
    }
}

你应该使用一个集合类来完成这件事，而不是自己管理它。看看“vector”类。它本质上是一个动态数组，可以根据需要自动调整大小。
在您的情况下，您将使用“vector”和“double”类型。您可能还需要阅读C++中的模板。
http://www.cplusplus.com/reference/stl/vector/

或者，如果你不想使用STL或其他动态的东西，你可以从一开始就创建一个大小正确的数组：x =新的双[2];
当然，问题是要做多大，如果你不知道，那么你就需要把它做得“足够大”。（比如100个，或者1000个）......到了某个时候，它可能会不够大，并且会以某种随机的方式失败。所以你需要调整它的大小。一旦你到了那个时候，你会希望你从一开始就使用STL，就像其他答案告诉你的那样。

#include <iostream>
using namespace std;
int main() {
    double *x = new double[2];
    x[0]=5;
    x[1]=6;
    cout << x[0] << "," << x[1] << endl;
    return 0;
}

下面是一个很好的例子，所以你可以看到这个模式：

#include <iostream>
using namespace std;

int main() {
    // Allocate some memory for a double array of size 1 and store
    // an address to the beginning of the memory in mem_address.
    double* mem_address = new double[1];

    // Assign 5 to the first element in the array.
    mem_address[0] = 5;

    // Save the address of the memory mem_address is currently
    // referencing.
    double* saved_address = mem_address;

    // Allocate some memory for a double array of size 2 and store
    // an address to the beginning of the memory in mem_address.
    mem_address = new double[2];

    // Copy over the 1 element from the first memory block
    // to the new one.
    mem_address[0] = saved_address[0];

    // Done with the old memory, so clean it up.
    delete [] saved_address;

    // Assign 6 to the second element in the new array.
    mem_address[1] = 6;

    // Print out the 2 elements in the new array.
    cout << mem_address[0] << "\n";
    cout << mem_address[1] << "\n";

    // Done with the new array memory now, so clean it up.
    delete [] mem_address;
}

如果由于某种原因，您无法访问STL --或者希望自己学习如何访问STL--您可以使用以下算法：
将数组分配为任意大小，并记住数组中有多少个元素以及数组有多大：

int *a = malloc(int * ARBITRARY_SIZE);
int size = 0;
int allocated = ARBITRARY_SIZE;

每次添加一个新元素时，增加“size”。2如果size等于ARBITRARY_SIZE，则将“allocated”乘以2，然后重新分配数组。3无论哪种方式，都将新值赋给一个[size]。

void addElement(int value) {
  ++size;

  if (size == allocated) {
    allocated *= 2;
    a = realloc(sizeof(int) * allocated);
    a = new_a;
  }

  a[size] = value;
}

注意，上面的代码至少有一个bug --在这两种情况下都没有为x[1]分配足够的空间。
同样明显的是，在真实的代码中，你会检查malloc & realloc的返回值是否不为空。

一个数组总是需要一个连续的内存块。在你以后可能需要调整数组大小的情况下，重新分配可能是唯一的解决方案。这就是Moishe和Shadow2531在上面所做的。
重新分配的问题在于它可能是一个代价高昂的操作，所以如果你需要在一个5000个元素的数组中再添加5个元素，你可能会在整个内存中复制所有的5000个元素。
在这种情况下可以考虑使用链表。