Question

好的，我已经读完了，似乎无法找到符合我问题的答案。 This是我能找到的最接近的。

我的情况是：我有三组变量，程序执行集合A，并根据用户指定的标志设置B或设置C.所有集合的值也是用户定义的。目前，我有这样的事情：

#include <iostream>
#include <string>
#include <cmath>

int main()
{
    //Set A
    double a,b,c;
    bool flag;

    std::cout << "Set Flag" << '\n';
    std::cin >> flag;

    if(flag)
    {
        //Set B
        double x1,x2,y1,y2,z;
        std::cout << "Set Variable X1." << '\n';
        std::cin >> x1;

        std::cout << "Set Variable X2." << '\n';
        std::cin >> x2;

        std::cout << "Set Variable Y1." << '\n';
        std::cin >> y1;

        std::cout << "Set Variable Y2." << '\n';
        std::cin >> y2;

        std::cout << "Set Parameter Z." << '\n';
        std::cin >> z;

        //Some operations based on set B
        a = x+y;

    }
    else
    {
        //Set C
        double t,u,v;
        std::cout << "Set Variable T." << '\n';
        std::cin >> t;

        std::cout << "Set Variable U." << '\n';
        std::cin >> u;

        std::cout << "Set Parameter V." << '\n';
        std::cin >> v;

        //Some operations based on set C
        a = t+u;

    }

    // I want to do more operations common to both sets here using data from selected set...
    // Write to file, etc.
}

哪种方式会更好：首先声明所有可能的变量，或者完全分叉代码，使得if / else代码完成，因为标志会改变几个关键步骤，尽管我想要做的很多事情都是类似的。

条件之间的主要区别在于，如果标志为true，则程序使用多个数组/向量，而如果标志为false则使用单个值。

Answer 1

是什么让你认为不可能或不推荐？

回到C中的旧时代，你必须提前声明所有变量，但这不再是必要的。您可以在需要时以及需要时自由地声明变量。它更容易，更灵活，IMO也更具可读性，因为它与意图一起流动。

根据运行时值，您的程序可能会采用不同的方向，并执行不同的操作，这需要不同的变量。如果所有代码路径都可以使用一组变量，则可以提前声明并在任何情况下使用它们。

Answer 2

首先，在C ++中，将变量声明为尽可能狭窄的范围是一种很好的做法。所以你的示例代码确实正确。为了便于阅读，我将一些代码放入函数中：

#include <iostream>
#include <string>
#include <cmath>

double inputDouble(const std::string& question) {
    std::cout << question << std::endl;
    double r;
    std::cin >> r;
    return r;
}

double handleB() {
    //Set B
    double x = inputDouble("Set Variable X.");
    doubly y = inputDouble("Set Variable Y.");
    double z = inputDouble("Set Parameter Z.");

    //Some operations based on set B
    return x+y;    
}

double handleC() {
        //Set C
        double t = inputDouble("Set Variable T.");
        double u = inputDouble("Set Variable U.");
        double v = inputDouble("Set Parameter V.");

        //Some operations based on set C
        a = t+u;    
}

int main() {
    //Set A
    bool flag;

    std::cout << "Set Flag" << '\n';
    std::cin >> flag;

    double a = (flag) ? handleB() : handleC();

    // whatever you plan with a
}

当然，你的函数也可以返回更复杂的对象。

Answer 3

如何使用联盟。您的补充数据集需要具有相同的大小，否则您必须注意缓冲区溢出...

var canvas = document.querySelector('#canvas'),
    height = canvas.height = canvas.clientHeight,
    width = canvas.width = canvas.clientWidth,
    ctx = canvas.getContext('2d');
canvas.width = canvas.height = 512;

var shipx = 400,
    shipy = 256;

function moveShip() {
    ctx.fillStyle = '#000';
    ctx.fillRect(0, 0, canvas.width, canvas.height);

    ctx.save();
    ctx.translate(shipx, shipy);
    ctx.rotate(3.66);
    ctx.fillStyle = 'green';
    ctx.fillRect(0, 0, 80, 20);
    ctx.restore();

    // This is what isPointInPath is seeing
    ctx.fillStyle = 'rgba(0,0,255,0.5)';
    ctx.fillRect(shipx, shipy, 80, 20);

    ctx.fillStyle = 'rgba(255,0,0,0.5)';
    ctx.beginPath();
    ctx.moveTo(256, 256);
    ctx.arc(256, 256, 100, -20 * Math.PI / 180, 90 * Math.PI / 180);
    ctx.lineTo(256, 256);

    if (ctx.isPointInPath(shipx, shipy) || ctx.isPointInPath(shipx + 20, shipy + 20)) {
        // This *should* trigger
        ctx.fillStyle = 'rgba(0,0,255,0.5)';
    };

    ctx.fill();
}

moveShip();

c ++：是否可以/建议根据运行时条件声明变量？

3 个答案: