函数类型   	operator	重载运算符（形参表）
{
	函数体；
}
//非成员函数
friend	函数类型	operator	重载运算符（形参表）
{
	函数体；
}

#include<iostream>
using	namespace	std;
class MyClass2
{
	int n;
public:
	MyClass2(int i){ n = i; }
	int operator ++(){ n++; return n; }
	int operator ++(int){ n += 2; return n; }
	void display()
	{
		cout << "n=" << n << endl;
	}
};

int main()
{
	MyClass2 A(5), B(5);
	A++;
	++B;
	A.display();
	B.display();
    return 0;
}

obj1.operator op(obj2)

obj1 op(obj1,obj2)

void	*类名：：operator	new(size_t,参数表)；
void* operator new(size_t size,int x,int y,int z)
{……
}
void *类名“::operator delete(void*,参数表);

x*pX=new(1,2,3) X;

class Stock{
    public:
     Stock(double t){
        value = t;
     }
    int value;
}

operator 类型名（）
{
	函数体；
}

函数类型 类名：：operator()(参数表)

输出流 <<  obj
输入流 >>  obj 

#include<iostream>
using namespace std;
class Person {
	friend ostream& operator<<(ostream& out, Person& p);

public:

	Person(int a, int b)
	{
		this->m_A = a;
		this->m_B = b;
	}

	//成员函数 实现不了  p << cout 不是我们想要的效果
	//void operator<<(Person& p){
	//}

private:
	int m_A;
	int m_B;
};

//全局函数实现左移重载
//ostream对象只能有一个
ostream& operator<<(ostream& out, Person& p) { 
    		//ostream是标准的输出流，全局只能有一个，所以用引用引用的方式
	out << "a:" << p.m_A << " b:" << p.m_B;
	return out;
}

void test() {

	Person p1(10, 20);

	cout << p1 << "hello world" << endl; //链式编程
}

int main() {

	test();

	return 0;
}

#include<iostream>
using	namespace	std;
class MyClass2
{
	int n;
public:
	MyClass2(int i){ n = i; }
	MyClass2 operator +(int a){ n+=a; return n; }
	void display()
	{
		cout << "n=" << n << endl;
	}
    friend  MyClass2 operator +(MyClass2 a, int  b){ 
       a.n += b;
       return a;
    }
};

int main()
{
	MyClass2 A(5), B(5);
    A = 5 + A;// 会报错
	A.display();
	B.display();
    return 0;
}

Stock a(1.0);
double b = 2.0;
Stock total;
total = a + b;// 将b转成Stock，再相加

S -> void main(){B}
B -> Y;
Y -> Y;STATEMENT | e
STATEMENT -> D | A | BLOCK
D -> TYPE id | TYPE* id
BLOCK -> IF(C){B} ELSE{B} | while(C){B}
A -> id + id | id -id | id * id | id /id 

type exprLexer interface {
	Lex(lval *exprSymType) int
	Error(s string)
}

type exprParser interface {
	Parse(exprLexer) int
	Lookahead() int
}

func (x *exprLex) Lex(yylval *exprSymType) int {
	for {
		c, _, err := x.input.ReadRune()
		if err != nil {
			return eof
		}
		switch c {
		case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
			return x.num(c, yylval)
		case '+', '-', '*', '/', '(', ')':
			return int(c)
		case '×':
			return '*'
		case '÷':
			return '/'

		case ' ', '\t', '\n', '\r':
		default:
			log.Printf("unrecognized character %q", c)
		}
	}
}

// Lex a number.
func (x *exprLex) num(c rune, yylval *exprSymType) int {
	var b bytes.Buffer
	b.WriteRune(c)
L:
	for {
		c, _, err := x.input.ReadRune()
		if err != nil {
			return eof
		}
		switch c {
		case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.', 'e', 'E':
			b.WriteRune(c)
		default:
			_ = x.input.UnreadRune()
			break L
		}
	}
	yylval.num = &big.Float{}
	_, ok := yylval.num.SetString(b.String())
	if !ok {
		log.Printf("bad number %q", b.String())
		return eof
	}
	return NUM
}

func (x *exprLex) Error(s string) {
	log.Println("parse error: ", s)
}

%{

package main
import (
	"fmt"
	"math/big"
)

%}

%union {
    num *big.Float
}

%type <num> expr expr1 expr2 expr3 //  定义在后面的符号比定义在前面的符号具有更好的优先级

%token '+' '-' '*' '/' '(' ')'

%token	<num> NUM

%%

top:
expr
{
    if $1.IsInt() {
	fmt.Println($1.String())
    } else {
        fmt.Println($1.String())
    }
}

expr:
expr1
{}
|
'+' expr
{
    $$ = $2
}
|
'-' expr
{
    $$ = $2.Neg($2)
}
;

expr1:
expr2
{}
|
expr1 '+' expr2
{
    $$ = $1.Add($1, $3)
}
|
expr1 '-' expr2
{
    $$ = $1.Sub($1, $3)
}
;

expr2:
expr3
{}
|
expr2 '*' expr3
{
    $$ = $1.Mul($1, $3)
}
|
expr2 '/' expr3
{
    $$ = $1.Quo($1, $3)
}
;

expr3:
NUM
|
'(' expr ')'
{
    $$ = $2
}

%%

func main() {
	in := bufio.NewReader(os.Stdin)
	a := big.Float{}
	a.String()
	for {
		if _, err := os.Stdout.WriteString("> "); err != nil {
			log.Println("WriteString: ", err)
		}
		line, err := in.ReadBytes('\n')
		if err == io.EOF {
			return
		}
		if err != nil {
			log.Fatalf("ReadBytes: %s", err)
		}
    //调用分析器
		exprParse(newExprLex(line))
	}
}

%{
package jsonparser

type pair struct {
  key string
  val interface{}
}

func setResult(l yyLexer, v map[string]interface{}) {
  l.(*lex).result = v
}
%}

%union{
  obj map[string]interface{}
  list []interface{}
  pair pair
  val interface{}
}

%token LexError
%token <val> String Number Literal

%type <obj> object members
%type <pair> pair
%type <val> array
%type <list> elements
%type <val> value


%start object

%%

object:
'{' members '}'
{
	$$=$2
	setResult(yylex, $$)
}

members:
{
	$$ = map[string]interface{}{}
}
| pair
{
	$$ = map[string]interface{}{$1.key: $1.val}
}
| members ',' pair
{
	$1[$3.key] = $3.val
	$$ = $1
}

pair:
String ':' value
{
	$$ = pair{key: $1.(string), val: $3}
}

array: '[' elements ']'
{
	$$ = $2
}


elements:
{
	$$=[]interface{}{}
}
| value
{
	$$=[]interface{}{$1}
}
|
elements ',' value
{
	$$=append($1, $3)
}

value:
  String
| Number
| Literal
| object
  {
    $$ = $1
  }
| array