c++ - 你如何用 C++ 编写返回结构的函数原型(prototype)？

Question

我必须为二次方程创建二等分程序。以下是两个单独步骤的说明:

程序必须满足以下要求:

1. 二次方程的系数 a、b 和 c 应通过名为 readCoeffs() 的单独函数从键盘读取。该函数应向调用者返回一个读取了所有 3 个系数的结构。 t 可以是结构的 3 个字段或具有 3 元素数组的单个字段。

2. 计算根的函数应以具有 3 个字段的结构形式将结果返回给调用方:root1、root2 和 exists(用于确定根是否存在的 bool 变量)。

我无法正确编写函数原型(prototype)和函数标题。当我这样写它们时:

struct calcRoots(double, double, double, double quadfunc(double), bool&);

struct readCoeffs();

int main(){

我收到错误。我认为 Microsoft Visual Studio 希望我创建带有大括号和分号的结构。我很迷茫。非常感谢任何反馈。

这是我正在使用的全部代码。我在不断地修改它。这是我的第一门c++类(class)。我在挣扎。

/****************************************************************************
//File: bisect.cpp
//Finds the root of a function using the bisection method
#include <iostream>
#include <cmath>
#include <fstream>
using namespace std;

struct coeffStru{
        double a;
        double b;
        double c;};
struct rootStru{
    double root1;
    double root2;
    bool exists;
               };

//function prototypes
struct calcRoots(double, double, double, double f(double),bool&);
double quadfunc(struct, double);
struct readcoeffs(coeffStru);

int main() {
    double xLeft=-10.0;
    double xRight=10.0; //end points of interval
    double epsilon;       //exists tolerance
    double root;          //root found by bisect
    bool exists;              //exists flag

//Get tolerance
cout<< "Enter tolerance: ";
cin>>epsilon;

struct coeffStru = readcoeffs();

//use bisect calcRoots function to look for root of function f
struct rootStru = calcRoots(xLeft, xRight, epsilon, quadfunc, exists);




//display result
if (!exists){
    cout<< "Root found at "<<root
        <<" \nValue of f(x) at root is: "<<f(root);
        system("PAUSE");
        return 0;
           }
else{
    cout<<"There may be no root in ["<<xLeft<<", "<<xRight<<"]"<<endl;
    system("PAUSE");
    return 0;
    }
}




//Struct return type readcoeffs function
struct readcoeffs(coeffStru){

    cout<<"Enter values for a,b,and c of a quadratic equation."<<endl;
    cin>>a>>b>>c;
    return struct coeffStru;
                            }








//Implements bisection method to find a root of function f
//in interval [xLeft, xRight].
//PRE: xLeft, xRight, and epsilon are defined.
//POST: Returns midpoint of xLeft and xRight if the difference between thses values is <= epsilon. Returns true to exists if there is no root.
struct calcRoots (double xLeft, double xRight, double epsilon, struct coeffStru, double quadfunc(double), bool& exists) //IN: endpoints of interval for possible root, IN: exists tolerance, IN: the function, OUT: exists flag
{
    double xMid;                        //midpoint of interval
    double fLeft;
    double fRight;              //function values at xLeft, xRight,
    double fMid;                        //and xMid


//Compute function values at initial endpoints of interval
    fLeft = quadfunc(xLeft,coeffStru);
    fRight = quadfunc(coeffStru, xRight);


    //Repeat while interval > exists tolerance
    while (fabs ( xLeft - xRight) > epsilon)
    {
        //Compute function value at midpoint
        xMid = (xLeft + xRight)/ 2.0;
        fMid = quadfunc(coeffStru, xMid);

        //Test function value and reset interval if root not found
        if(fMid ==0.0)      //if xMid is the root
            root1 = xMid;    //set root1 to xMid
        else{ 
            xRight = xMid;
            xMid = (xLeft + xRight)/ 2.0;
            fMid = f(coeffStru, xMid);
            }
            if(fLeft * fMid < 0.0)  //root in [xLeft, xMid]





        //Display next interval
        cout<< "New interval is [" <<xLeft
            << ", " <<xRight << "]"<<endl;
    }    //ends 1st while loop


    //If no change of sign in the interval, there is no unique root
    exists = (fLeft * fRight) >0;  //test for same sign - set exists
    if(exists){ 
        return -999.0;      //no 1st root - return to caller
              }


    //Return midpoint of last interval
    root1 = (xLeft + xRight) / 2.0;
//Compute function values at initial endpoints of interval
    fLeft = f(coeffStru, xLeft);
    fRight = f(coeffStru, xRight);



    //Repeat while interval > exists tolerance
    while (fabs ( xLeft - xRight) > epsilon)
    {
        //Compute function value at midpoint
        xMid = (xLeft + xRight)/ 2.0;
        fMid = f(coeffStru, xMid);

        //Test function value and reset interval i root not found
        if(fMid ==0.0)      //xMid is the root
            return xMid;    //return the root
        else if (fLeft * fMid < 0.0)  //root in [xLeft, xMid]
            xRight = xMid;
        else                            //root in [xMid, xRight]
            xLeft = xMid;

        //Display next interval
        cout<< "New interval is [" <<xLeft
            << ", " <<xRight << "]"<<endl;
     }    //ends 2nd while loop


    //If no change of sign in the interval, there is no unique root
    exists = (fLeft * fRight) > 0;  //test for same sign - set exists
    if(exists){ 
        return -999.0;      //no 2nd root - return to caller
              }


    //Return midpoint of last interval
    root2 = (xLeft + xRight) / 2.0;

return struct rootStru;
}   //ends calcRoots method




//Function whose root is being found.
//PRE: x is defined.
//POST: Returns f (x)
double quadfunc(struct coeffStru, double x){
    return a * pow(x, 2.0) - b* pow(x, 1.0) + c;}


************************************************************/

如您所想，我遇到了很多错误。我现在的主要问题似乎是通过引用和值传递变量和结构。

Answer 1

这是一个两步过程:

(1) 定义将保存结果的结构，可能是这样的:

struct ResultType {
    /* ... fields go here ... */
};

(2) 原型(prototype)实际功能:

ResultType calcRoots(double a, double b, double c, double function(double), bool& out);

希望这对您有所帮助!