Error c2059 синтаксическая ошибка return

oh shoot, sorry

//expression.h

#ifndef EXPRESSION_H
#define EXPRESSION_H

namespace Student
{

enum TagType //For labeling data content in a binary expression tree node.
{
    INT_ONLY,
    SUB_NODE
};

struct NodeType //For nodes in a binary expression tree.
{
    TagType tag;
    union //Note that this union type is "anonymous".
    {
        int intValue;
        struct //And this struct type is also anonymous.
        {
            NodeType* left;
            char op;
            NodeType* right;
        };
    };
};

class Expression
{
public:
    bool Expression::isRead
    (
        istream& inStream //inout
    );
    /**<
    Determines if a valid expression can be read from inStream and, if so,
    reads and stores the expression.
    @param inStream The input stream from which the expression is read.
    @return true if an expression has been successfully read from inStream,
    otherwise false.
    @pre inStream has been initiallzed and is open for reading.
    @post inStream is still open for reading. An expression may or may not
    have been successfully read.
    */


    void display() const;
    /**<
    Displays an arithmetic expression. If the expression is a single
    non-negative integer, it simply displays that integer. Otherwise
    it displays the expression fully parenthesized, with a single
    blank space before, and a single blank space after, each operator.
    @pre This expression has been initialized.
    @post This expression has been displayed, as above, starting from
    the current cursor position. Note too that this method does not
    terminate the line on which the expression is displayed.
    */


    int getValue() const;
    /**<
    Returns the value of this expression.
    */

private:
    NodeType eTree;
};

} //End of this part of namespace Student

#endif

also, the isRead function is taken care of by my profs .obj file. So I don’t have a written function for that

Your signatures are inconsistant. Once you fix there will be other problems…

void writeNode(NodeType* node);
void writeNode(NodeType node)

ok, that has been fixed, but I’m still getting the same errors. The new code

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


namespace Student
{
    
    void writeNode(NodeType* node);
    /*
    Displays an arithmetic expression.
    @pre The node is initialized.
    @post This node has been displayed.
    */

    int answer(NodeType* node);
    /*
    returns the value of the SUB_NODE, or the value
    if node is just an int.
    */
    
    void Expression::display() const
    {
        writeNode(eTree*);    //error here
    }

    int Expression::getValue() const
    {
        return answer(eTree*);  //error here
    }
    
    void writeNode(NodeType* node)
    {
        if(node->tag == SUB_NODE)
        {
            cout<<"(";
            writeNode(node->left);
            cout<< node->op;
            writeNode(node->right);
            cout<<")";
        }
        else if(node->tag == INT_ONLY)
            cout<<node->intValue;
    }
    int answer(NodeType* node)
    {
        if(node->tag == INT_ONLY)
            return node->intValue;
        else
        {
            switch(node->op)
            {
            case '+':
                return answer(node->left) + answer(node->right);
            case '-':
                return answer(node->left) - answer(node->right);
            case '*':
                return answer(node->left) * answer(node->right);
            case '/':
                return answer(node->left) / answer(node->right);
            }
        }   
    }
}

What is eTree??

void Expression::display() const
{
    writeNode(eTree*);    //error here
}

it is the head node of the expression tree.

do you want to pass eTree * or perhaps &eTree

^^yes actually I do, but if i change that eTree is a const NodeType* while each recursive call will simply be NodeType*

try this and see what happens, then figure out how it should be fixed

struct node_t
{
    node_t *left;
    node_t *right;
};

void something(node_t *)
{
}

int main()
{
    node_t node;

    something(node*); // #1 what is this??
    something(&node); // #2 pass a pointer to node
}

Line 35 in class Expression, you are missing semicolon at the end.

istream& inStream //inout

thats a parameter for the function

Also, just out of curiosity, why did you decide to use an anonymous struct below?

struct NodeType //For nodes in a binary expression tree.
{
    TagType tag;
    union //Note that this union type is "anonymous".
    {
        int intValue;
        struct //And this struct type is also anonymous.
        {
            NodeType* left;
            char op;
            NodeType* right;
        };
    };
};

that part was done by my prof. In all honesty, I’m not quite sure

If eTree is a NodeType you have to call function(NodeType* node) like so: function(&eTree);

Ask him why when you get a chance, probably has a good reason, although anonymous struct is not part of the c++ standard to the best of my knowledge.

Will do, I have found a way that works. Thanks for your help. In case your curious this is my new code

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


namespace Student
{
    
    void writeNode(const NodeType* node);
    /*
    Displays an arithmetic expression.
    @pre The node is initialized.
    @post This node has been displayed.
    */

    int answer(const NodeType* node);
    /*
    returns the value of the SUB_NODE, or the value
    if node is just an int.
    */
    
    void Expression::display() const
    {
        writeNode(&eTree);
    }

    int Expression::getValue() const
    {
        return answer(&eTree);
    }
    
    void writeNode(const NodeType* node)
    {
        if(node->tag == SUB_NODE)
        {
            cout<<"(";
            writeNode(node->left);
            cout<< " "<<node->op<<" ";
            writeNode(node->right);
            cout<<")";
        }
        else if(node->tag == INT_ONLY)
            cout<<node->intValue;
    }
    int answer(const NodeType* node)
    {
        if(node->tag == INT_ONLY)
            return node->intValue;
        else
        {
            switch(node->op)
            {
            case '+':
                return answer(node->left) + answer(node->right);
            case '-':
                return answer(node->left) - answer(node->right);
            case '*':
                return answer(node->left) * answer(node->right);
            case '/':
                return answer(node->left) / answer(node->right);
            }
        }   
    }
}

Now I have the functions with const parameters and NodeType* node