int main()
{
    return 1$5; // имелось в виду 145
}

int main()
{
    return 0;
{ // неправильная скобка здесь

int main()
{
    i = 15;

    return 0;
}

WH>struct s
WH>{
WH>private:
WH>    void f() const;
WH>};

WH>int main()
WH>{
WH>    s ms;
    
WH>    ms.f();
WH>}
WH>

This summary of C++ syntax is intended to be an aid to comprehension. It is not an exact statement of the language. In particular, the grammar described here accepts a superset of valid C++ constructs. Disambiguation rules (§A.5, §A.7) must be applied to distinguish expressions from declarations.Moreover, access control, ambiguity, and type rules must be used to weed out syntactically valid but meaningless constructs.

int main()
{
    i = 0;
}

struct s
{
private:
    void f() const;
};

int main()
{
    s ms;
    
    ms.f();
}

In particular, the grammar described here accepts a superset of valid C++ constructs.

Moreover, access control, ambiguity, and type rules must be used to weed out syntactically valid but meaningless constructs.

a<b>c;

XC>это не коммерческий проект, для коммерческого я бы скачал бы что нибудь готовое и бесплатное это просто изучение интересной для меня темы.

struct s
{
private:
       void f() const;
};

int main()
{
       s ms;

       ms.f();
}

a b((c)d);

WH>Ой там их столько что С++ вобще крайне хреново спроектирован.

WH>a<b>c;
WH>

Parsing the syntax of C++ is the easy part of the problem. Once you have an abstract syntax tree, you need to do semantic analysis to figure out which functions are being called and which variables are being referenced at each point in your program. A call to "foo" somewhere in the application could refer to a top-level function called "foo", or a method within the current class, or one of its (possibly multiple) base classes. There could be several overloaded versions of "foo" with different argument types, possibly with some default parameters, in each of these places. There may be some other "foo"'s available which take arguments which are subtypes of the supplied arguments. And on top of that, C++ allows implicit coercion between types, so the types of the arguments could get totally changed. Your semantic analysis stage has to codify all of these rules, in the right order.

    public static GetTokens(text : string) : list[Token]
    {
        mutable pos = 0;
        mutable line = 1;
        mutable linePos = 1;
        mutable deep = 0;

        def end() { pos >= text.Length }

        def curPos() { Pos(pos, line, linePos) }

        def substr(start) { text.Substring(start.Pos, curPos().Pos - start.Pos) }

        def isAlpha(c)    { ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') }
        def isNum(c)      { ('0' <= c && c <= '9') }
        def isAlphaNum(c) { isAlpha(c) || isNum(c) }
        def isSpace(c)
        {
        | ' ' | '\t' | '\n' | '\r' => true
        | _ => false
        }

        def ch() { text[pos] }
        def nextCh()
        {
            def pos1 = pos + 1;
            if (pos1 >= text.Length)
                '\0'
            else
                text[pos1]
        }
        
        def checkEnd()
        {
            when (end())
                throw CompileError(line, linePos, $"Unexpected end of file.");
        }

        def check(c)
        {
            checkEnd();
            when (ch() != c)
                throw CompileError(line, linePos, $"$c expected.");
        }

        def unexpected(pos, c)
        {
            CompileError(pos.Line, pos.LinePos, $"Unexpected symbol: '$c'");
        }

        def move1()
        {
            when (ch() == '\n')
            {
                ++line;
                linePos = 0;
            }
            ++pos;
            ++linePos;
        }

        def move(n)
        {
            for (mutable i = 0; !end() && i < n; ++i)
                move1();
        }

        def moveWhile(fn)
        {
            while (!end() && fn(ch()))
                move1();
        }

        def skipSpace()
        {
            moveWhile(isSpace);
        }

        def parseIdentifier()
        {
            def start = curPos();
            moveWhile(isAlphaNum);
            def end = curPos();
            def name = substr(start);
            skipSpace();
            if (ch() == '.')
            {    
                def start = curPos();
                move(1);
                skipSpace();
                if (isAlpha(ch()))
                {
                    def (names, end) = parseIdentifier();
                    (name :: names, end);
                }
                else
                    throw unexpected(start, '.');
            }
            else
                ([name], end);
        }

        def parse()
        {
            skipSpace();
            if (end())
            {
                [];
            }
            else 
            {    
                def start = curPos();
                match (ch())
                {
                | c when isAlpha(c) => 
                    def (name, end) = parseIdentifier();
                    Token.Identifier(start, end, name) :: parse();
        
                | '{' => parseBrace() :: parse()
                | '}' when deep > 0 => []
        
                | '(' => parseRound() :: parse()  
                | ')' when deep > 0 => []
        
                | ':' => move(1); Token.Colon     (start, curPos()) :: parse();
                | ';' => move(1); Token.Semicolon (start, curPos()) :: parse();
                | ',' => move(1); Token.Comma     (start, curPos()) :: parse();
        
                | '!' | '?' | '*' | '+' | '|'
                      => move(1); Token.Operator(start, curPos(), substr(start)) :: parse();

                | '-' when nextCh() == '>'
                      => move(2); Token.Operator(start, curPos(), substr(start)) :: parse();

                | _   => throw unexpected(start, ch());
                } 
            }
        }
        and parseBracket(close)
        {
            def start = curPos();
            move(1);
            ++deep;
            def tokens = parse();
            --deep;
            check(close);
            move(1);
            (start, tokens)
        }
        and parseBrace()
        {
            def (start, tokens) = parseBracket('}');
            Token.Brace(start, curPos(), tokens)
        }
        and parseRound()
        {
            def (start, tokens) = parseBracket(')');
            Token.Round(start, curPos(), tokens)
        }
        parse();
    }

prop = setter | getter | (setter getter) | (getter setter);

prop = *(setter | getter);

WH>prop = setter | getter | (setter getter) | (getter setter);
WH>

WH>prop = *(setter | getter);
WH>

property -> prop_list | prop;
prop -> setter | getter | (setter getter) | (getter setter)
prop_list -> prop; prop_list | prop;

int main()
{
   int a = 1 + 2;
   return 0;
}

Programming Language = Syntax + Semantics