一个问题set对于学习 C++ 的人来说是

Write a short program to simulate a ball being dropped off of a tower. To start, the user should be asked for the initial height of the tower in meters. Assume normal gravity (9.8 m/s2), and that the ball has no initial velocity. Have the program output the height of the ball above the ground after 0, 1, 2, 3, 4, and 5 seconds. The ball should not go underneath the ground (height 0).

在开始使用 C++ 之前，我有一定的 Java 知识，但主要是自学的。所以看看这个问题，它似乎应该被分成

• 输入类
• 输出类
• 计算课
• 物理常数类(出题人推荐)
• Controller ('main')类

输入类会询问用户起始高度，该高度将传递给 Controller ​​。 Controller 会将这个和数秒 (5) 提供给计算类，计算类将创建一个结果数组并将其返回给 Controller 。 Controller 会将结果数组传递给输出类，输出类将结果打印到控制台。

我会将实际代码放在底部，但可能不需要。

您可能已经看到了问题，试图返回一个数组。我不是在问如何解决这个问题，有一个解决方法 here和 here .我在问，问题是不是设计不当造成的？出于性能、维护或样式的原因，我的程序是否应该采用不同的结构，这样我就不会尝试返回一个类似对象的数组？

这是代码(除了尝试返回数组外)；

主要.cpp

/*
 * Just the main class, call other classes and passes variables around
 */
#include <iostream>
#include "dropSim.h"
using namespace std;

int main()
{
    double height = getHeight();
    int seconds = 5;
    double* results = calculateResults(height, seconds);
    outputResults(results);
    return 0;
}

获取高度.cpp

/*
 *  Asks the user for a height from which to start the experiment
 *  SI units
 */
#include <iostream>
using namespace std;

double getHeight()
{
    cout << "What height should the experiment start at; ";
    double height;
    cin >> height;
    return height;
}

计算结果.cpp

/*
 * given the initial height and the physical constants, the position of the ball
 * is calculated at integer number seconds, beginning at 0
 */

#include "constants.h"
#include <cmath>
#include <iostream>
using namespace std;

double getPosition(double height, double time);

double* calculateResults(double height, int seconds)
{

    double positions[seconds + 1];
    for(int t = 0; t < seconds + 1; t++)
    {
        positions[t] = getPosition(height, t);
    }
    return positions;
}

double getPosition(double height, double time)
{
    double position = height - 0.5*constants::gravity*pow(static_cast<double>(time), 2);
    if( position < 0) position = 0;
    //Commented code is for testing
    //cout << position << endl;
    return position;
}

输出结果.cpp

/*
 *      Takes the array of results and prints them in an appropriate format
 */


#include <iostream>
#include <string>
#include <sstream>

using namespace std;

void outputResults(double* results){
    string outputText = "";
    //The commented code is to test the output method
    //Which is working
    //double results1[] = {1,2,3,4,5};
    //int numResults = sizeof(results1)/sizeof(results1[0]);
    int numResults = sizeof(results)/sizeof(results[0]);
    //cout << numResults; //= 0 ... Oh
    for(int t = 0; t < numResults; t++)
    {
        ostringstream line;
        line << "After " << t << " seconds the height of the object is " << results[t] << "\r";
        outputText.append(line.str());

    }
    cout << outputText;
}

最后是几个标题； dropSim.h

/*
 * dropSim.h
 */

#ifndef DROPSIM_H_
#define DROPSIM_H_

double getHeight();

double* calculateResults(double height, int seconds);

void outputResults(double* results);

#endif /* DROPSIM_H_ */

常量.h

/*
 *      Contains physical constants relevant to simulation.
 *      SI units
 */

#ifndef CONSTANTS_H_
#define CONSTANTS_H_

namespace constants
{
    const double gravity(9.81);
}

#endif /* CONSTANTS_H_ */

最佳答案

我会说你过度设计了一个小问题的大解决方案，但要回答你的具体问题:

Should my program be structured differently, for performance, maintenance or style reasons, such that I would not be attempting to return an array like object?

返回一个类似数组的对象是可以的。但这并不意味着返回数组，也不意味着使用 new 分配原始内存。

而且它也不限于返回值。当您开始使用 C++ 时，最好完全忘记它具有内置数组。大多数时候，您应该使用 std::vector 或 std::array(或另一个线性集合，例如 std::deque).

内置数组通常应被视为具有特殊用途的项目，主要是为了与 C 兼容，而不是日常使用。

但是，可能值得考虑以与标准库中的算法相同的风格编写您的计算。这意味着编写代码以将迭代器接收到目的地，并将其输出写入迭代器指定的任何位置。

我可能会将高度和时间打包为一组输入参数，并有一个基于这些参数生成输出的函数:

struct params {
    double height;
    int seconds;
};

template <class OutIt>
void calc_pos(params const &p, OutIt output) { 
    for (int i=0; i<p.seconds; i++) {
        *output = get_position(p.height, i);
        ++output;
    }
}

这与标准库的其余部分一起工作得更清楚:

std::vector<double> results;

calc_pos(inputs, std::back_inserter(results));

如果您愿意，您可以更进一步——标准库在这方面有很多帮助。您的 calc_pos 只是用当时的连续值重复调用另一个函数。您可以(例如)使用 std::iota 生成连续时间，然后使用 std::transform 生成输出:

std::vector<int> times(6);

std::iota(times.begin(), times.end(), 0);

std::vector<double> distances;

std::transform(times.begin(), times.end(), compute_distance);

这里计算的距离是在给定时间段后下降的距离，而不是地面以上的高度，但给定初始高度，计算两者之间的差异是非常微不足道的:

double initial_height = 5;

std::vector<double> heights;

std::transform(distances.begin(), distances.end(), 
    std::back_inserter(heights),
    [=](double v) { return max(initial_height-v, 0); });

至少现在，这不会尝试计算球在撞击地面时的弹跳——它只是假设球在撞击地面时立即停止。

关于c++ - 我应该尝试返回一个数组，还是有更好的解决方案？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/30646677/