Overview of the Volleyball Superliga Women in Bulgaria
The Volleyball Superliga Women in Bulgaria is one of the most anticipated sporting events in the country, showcasing the pinnacle of women's volleyball talent. As teams battle it out on the court, fans eagerly anticipate each match, analyzing team dynamics and player performances to predict outcomes. This article provides an expert analysis of tomorrow's matches, complete with betting predictions and insights into team strategies.
Key Teams to Watch
Tomorrow's matches feature some of the top teams in the league, each bringing their unique strengths and strategies to the court. Understanding these teams' recent performances and key players is crucial for making informed betting predictions.
Team A: A Formidable Force
Team A has been in excellent form this season, consistently outperforming their rivals. Their star player, known for her powerful serves and strategic plays, has been instrumental in their recent victories. The team's cohesive gameplay and strong defensive tactics make them a formidable opponent.
Team B: Rising Stars
Team B, while relatively new to the top tier, has shown remarkable improvement over the season. Their young roster is brimming with talent, particularly their dynamic duo who have been pivotal in tight matches. Their aggressive playing style and quick reflexes make them unpredictable and exciting to watch.
Match Predictions and Betting Insights
With tomorrow's matches set to captivate audiences, here are some expert predictions and betting insights:
- Team A vs Team C: Team A is favored to win due to their consistent performance and home-court advantage. Betting on a close victory could be lucrative.
- Team B vs Team D: This match promises to be a thrilling encounter. Team B's youthful energy could upset Team D's seasoned lineup. Consider placing bets on an underdog victory.
- Team E vs Team F: Both teams have had mixed results this season. However, Team E's strong defense might give them the edge. Look for bets on a low-scoring game.
Analyzing Player Performances
Key player performances can significantly influence match outcomes. Here are some players to watch:
- Maria Ivanova (Team A): Known for her exceptional serving skills, Maria has been a game-changer for Team A.
- Elena Petrova (Team B): Elena's agility and quick decision-making make her a crucial asset for Team B.
- Nadia Kostova (Team C): With her strategic playmaking abilities, Nadia often dictates the pace of the game for Team C.
Tactical Analysis
Understanding team tactics can provide deeper insights into potential match outcomes:
- Offensive Strategies: Teams with strong offensive plays often dominate possession time and score more points.
- Defensive Tactics: Effective blocking and defensive formations can disrupt opponents' rhythm and lead to turnovers.
- Servings: Powerful serves can put immediate pressure on opponents, leading to unforced errors.
Betting Tips for Tomorrow’s Matches
Here are some tips for those interested in betting on tomorrow’s matches:
- Diversify Your Bets: Spread your bets across different outcomes to mitigate risk.
- Analyze Recent Form: Consider teams’ recent performances when making predictions.
- Favor Underdogs Strategically: Sometimes backing underdogs can yield high returns if they perform unexpectedly well.
- Pay Attention to Lineups: Changes in team lineups can affect performance dynamics significantly.
Potential Upsets
Upsets are always possible in sports, adding an element of unpredictability that makes betting exciting:
<|repo_name|>simsongg/MyBlog<|file_sep|>/source/_posts/深入理解计算机系统-第五章-表示与实现.md
---
title: 深入理解计算机系统-第五章-表示与实现
date: '2017-11-29'
categories: [读书笔记]
tags: [CSAPP]
---
# 第五章 表示与实现
## 表示
### 字面量
字面量是程序中出现的一种常量。比如整数字面量，字符串字面量等。C语言中，整数字面量可以是十进制、八进制和十六进制的。
### 常量和变量
常量是在编译时就能确定值的数据对象，变量是在运行时才能确定值的数据对象。
常量有两种形式：`符号常量`和`文字常量`。
#### 符号常量
符号常量由预处理器来处理，它用一个名字代表一个值。这个名字对于程序员来说更加直观，方便记忆，比如：
c
#define MAXSIZE /* 程序员可读性更强 */
#define TRUE /* 可以定义为1 */
#define PI /* 可以定义为3.1415926 */
#### 文字常量
文字常量指的是在源代码中直接写出的值。例如：
c
int i = -1234;
char c = 'A';
float f = -3.14;
double d = "hello world";
### 数据类型和结构
数据类型指的是一组值的集合和定义这些值之间可以进行什么样操作。数据结构指的是数据元素之间关系。
C语言中有四种基本类型：字符型、整型、浮点型、复数型（虽然C语言没有复数类型）；另外还有三种无类型：空类型（void）、枚举类型（enum）、结构体（struct）。
#### 字符型
字符型数据占据一个字节，并使用ASCII码表示其值。其中`' '`表示空字符。
#### 整型
整数分为有符号和无符号两种形式。无符号整数只能存储非负数，而有符号整数可以存储正负两类整数。
##### 补码法
补码法主要用于表示负整数。原理是将该数字对应绝对值的二进制取反后再加上1得到最终结果。
例如：计算机位宽为8位，则：
+5 -> b00000101
-5 -> b11111010
##### 原码法
原码法主要用于早期计算机系统中表示负整数。原理是在数字最高位加上符号位，正则为0，负则为1。
例如：计算机位宽为8位，则：
+5 -> b00000101
-5 -> b10000101
##### 移码法
移码法主要用于早期计算机系统中表示负整数。原理是将该数字对应绝对值的二进制取反后再在最高位加上1得到最终结果。
例如：计算机位宽为8位，则：
+5 -> b00000101
-5 -> b11111011
#### 浮点型
浮点型存储大多采用IEEE754标准格式，即浮点单精度32位或者双精度64位格式进行存储。其中浮点单精度32位格式如下所示：
其中sign占据一位来存储符号信息；exponent占据八位来存储指数信息；fraction占据23位来存储小数部分信息。
##### 特殊情况下浮点单精度32格式化规则如下所示：
#### 复数型
C语言不支持复数组成的复数组成的复数组成复杂数组成数据类型，但可以通过结构体来模拟该功能，并且可以通过结构体函数重载实现类似于其他编程语言中方法重载功能。
### 类型转换与强制转换操作符(强转)
强制转换操作符具有优先级高于一元操作符（包括前置递增运算、前置递减运算、一元减运算、一元加运算）但低于乘法、除法和取模运算，并且具有左结合律特性（从左至右进行求值）。其使用方式如下所示：
c
(type) expression;
// 或者
type(expression);
例如:
c
int x = (int) y; // 将y强制转换成int类型并赋给x。
double y = (double) x; // 将x强制转换成double类型并赋给y。
注意，在使用强转操作时需要注意以下几个问题：
* 强转不会改变表达式本身所属数据类型；
* 强转只影响当前表达式；
* 强转可能导致信息损失或溢出；
* 强转可能导致未定义行为；
* 强转可能会导致效率降低。
## 实现
### 数据对象与内存布局
<|file_sep|># MyBlog Source Code Repository
This repository contains my blog source code.
My blog website address is https://blog.simsongg.top/
My blog web framework is hexo.
## Usage
### Clone this repo & install dependencies.
bash
$ git clone [email protected]:simsongg/MyBlog.git && cd MyBlog && npm install && cnpm install --save hexo-cli -g && cnpm install --save hexo-renderer-pandoc -S && cnpm install --save hexo-generator-searchdb -S && cnpm install --save hexo-generator-feed -S && cnpm install --save hexo-generator-sitemap -S && cnpm install --save hexo-browsersync -S && cnpm install --save hexo-deployer-git -S && npm i markdown-it-container markdown-it-abbr markdown-it-footnote markdown-it-sub markdown-it-sup highlight.js@^9.x --save
### Create new post.
bash
$ hexo new "post title"
$ vim source/_posts/post-title.md # write post content here...
$ hexo generate # generate static files...
$ hexo server # start local server at localhost:4000...
$ open http://localhost:4000/
### Deploy your site.
bash
$ git add .
$ git commit -m "update"
$ git push origin master # push changes ...
$ ssh [email protected] "cd /www/wwwroot/blog.simsongg.top/;git pull" # deploy changes...
<|repo_name|>simsongg/MyBlog<|file_sep[TOC]
# 深入理解计算机系统-第三章 程序的编译与执行过程
## 编译系统概述
### 编译步骤
**编译器**将源代码翻译成目标代码（目标代码也称作目标文件），生成目标文件通常称作**汇编**过程。
**链接器**将各个目标文件及其依赖库链接生成可执行文件或共享库。
**加载器**把可执行文件或共享库从磁盘加载到内存并执行。
我们把上述三个步骤统称为程序执行过程。
当我们键入命令行`cc main.c`时，编译器将调用前端阶段程序把main.c翻译成汇编代码，并调用后端阶段程序把汇编代码翻译成可执行二进制代码，并调用连接器把各个目标文件链接生成可执行文件。
当我们键入命令行`./a.out`时，加载器把a.out从磁盘加载到内存并执行。
## 编译系统详解
### 前端阶段程序
前端阶段包含以下四个部分：
* 预处理器：根据预处理指令完成文本替换工作。
* 编译器：
* 分析器(解析器)：根据语法规则检查源代码是否存在语法错误。
* 综合优化器：对代码进行全局优化。
* 目标代码生成器：生成相应平台下汇编代码。
* 汇编程序：
* 符号解析程序：检查汇编文件是否存在歧义。
* 目标代码生成程序：生成相应平台下可重定向目标代码(即相应平台下目标文件)。
以上这些前端阶段都必须严格按照规定顺序完成工作，并且不能省略任何一个步骤。
#### 预处理阶段
预处理阶段主要任务就是完成文本替换工作，并输出新文本内容供后续步骤使用。
预处理指令以井号“#”开头，在预处理之前被移除掉，并且不产生任何警告或错误信息。
预处理指令分以下三类：
##### 文件引入指令(头文件引入)
头文件引入指令以“#include”开头，在引入头文件之前会先删除所有注释内容(包括多行注释)，然后再查找头文件并插入到当前位置。
查找头文件遵循以下顺序：
首先查找环境变量“CPPFLAGS”所指定路径；如果未找到则查找环境变量“CPATH”所指定路径；如果还未找到则按照默认搜索路径进行搜索。(环境变量设置方法见附录)
若未找到相应头文件，则报告错误信息“fatal error: file not found”，并停止编译过程。
若发现多次引入同一个头文件，则报告警告信息：“warning: ‘filename’ multiply included”，但不停止编译过程。(此处没有提供多次引入同一个头文件产生警告而不停止过程原因)
例子:
c++
#include//此处引入了stdio.h头文件内容
#include"myhead.h"//此处引入了myhead.h头文件内容
#include//此处引入了stdarg.h头文件内容
int main(){
printf("Hello World!n");
return ;
}
//经过预处理后输出结果如下：
printf("Hello World!n");
/*myhead.h*/
/*stdarg.h*/
int main(){
printf("Hello World!n");
return ;
}
//其中myhead.h和stdarg.h分别代表经过去除注释后myhead.h和stdarg.h真正内容，
//同时printf()函数被替换掉了，
//因为stdio.h里面已经定义了printf()函数，
//所以此处如果又定义了printf()函数就会报错，
//因此需要删除掉自己定义的printf()函数。
##### 宏定义及条件编译指令
###### 宏定义指令
宏定义指令以“#define”开头，
宏名称必须遵循以下规则:
名称只能由字母数字及下划线组成，
名称不能以数字开头，
名称区分大小写，
名称不能与保留关键字冲突.
宏参数只能由字母数字及下划线组成，
参数不能以数字开头，
参数区分大小写，
参数不能与保留关键字冲突.
宏定义格式如下:
c++
#define NAME MACRO_TEXT //普通宏
#define NAME(A,B,...) MACRO_TEXT //带参宏
#define NAME(A,B,...) MACRO_TEXT MACRO_TEXT_... //重复带参宏
#undef NAME //取消NAME宏
#ifdef NAME //NAME已经被声明
#else //NAME未被声明
#endif //结束#ifdef...else...endif块
#define PI /* 定义PI */ /* 这里就不做替换 */
#define LENGTH(x) ((x)->len)
#define AREA(x) ((x)->width * (x)->height)
struct rect{
int width;/* 宽 */
int height;/* 高 */
int len;/* 长 */
};
/* 这里开始做替换 */
AREA(struct rect s);
/* 输出结果 */
(s->width)*(s->height)
###### 条件编译指令
条件编译指令包括以下几种:
#ifdef name
#endif
#if expr
#endif
#if expr
#else
#endif
#if expr
#elif expr
#endif
#if expr
#elif expr
#else
#endif
#ifndef name
#endif
选择性地包含或排除某些部分源代码。
例子:
c++
#include
#ifdef DEBUG
void debug_msg(char *fmt,...){
}
#else
void debug_msg(char *fmt,...){
}
#endif
int main(void){
debug_msg("debug message...n");
return ;
}
/*
gcc test.c –DDEBUG=1 –O –Wall –ansi –pedantic –std=c99 –Wextra –Werror –I./inc ./test.c -lm > test.o
gcc test.c –O –Wall –ansi –pedantic –std=c99 –Wextra –Werror ./test.c > test.o
*/
/*
-DDEBUG=1 在命令行传递给 gcc 的选项，
意思就是设置 DEBUG 的值等于 “真”，那么 debug_msg() 函数就会被正确地展开，
否则就会被展开为空白函数。
*/
/*
-O 启动优化选项，在优化选项启动情况下，
GCC 不会展开那些没有被使用到的函数体，
因此如果没有启动优化选项那么两个版本都会产生完全相同的二进制输出。
*/
/*
-Wall 启动所有警告选项，在所有警告选项启动情况下，
GCC 不会展开那些没有被使用到的函数体，
因此如果没有启动所有警告选项那么两个版本都会产生完全相同的二进制输出。
*/
/*
-Wextra 启动额外警告选项，在额外警告选项启动情况下，
GCC 不会展开那些没有被使用到的函数体，
因此如果没有启动额外警告选项那么两个版本都会产生完全相同的二进制输出。
*/
/*
-Werror 把所有警告都当作错误来看待，在所有警告都当作错误看待情况下，
GCC 不会展开那些没有被使用到的函数体，
因此如果没有把所有警告都当作错误看待那么两个版本都会产生完全相同的二进制输出。
*/
/*
-g 添加调试信息，在添加调试信息情况下 GCC 不会去除没用到部分源代码块,
因此在添加调试信息情况下两个版本也会产生完全相同二进制输出.
*/
//#if DEBUG == FALSE 或者 #if !DEBUG 在预处理期间无法判断条件是否满足,
//故必须通过-DDEBUG=FALSE 或者-DDEBUG=TRUE 来设定条件是否满足.
/*
gcc test.c -DDEBUG=TRUE …… 或者 gcc test.c …… #define DEBUG TRUE …
gcc test.c …… 或者 gcc test.c …… #undef DEBUG
*/
###### 使用案例:
假设我们想要实现一个简单日志记录模块，
记录日志时需要记录日志级别、
记录日志时间、
记录日志消息等等,
这样做很明显违背了软件设计中关于封装、抽象等概念,
可以利用条件编译来提高模块灵活性,
首先建立一个配置 header 文件 config_log.h , 在里面写上一堆配置,
然后利用条件编译来选择性地打开关闭某些特性.
config_log.h:
c++
#ifndef _CONFIG_LOG_H_
#define _CONFIG_LOG_H_
#include
#ifdef LOG_DEBUG_MSG_ENABLED
#define LOG_DEBUG_MSG(msg,...)
do{
printf("[%s:%d][Debug] ",__FILE__,__LINE__);
printf(msg,(##__VA_ARGS__));
}while(0);
#else
#define LOG_DEBUG_MSG(msg,...)
#endif
#ifdef LOG_INFO_MSG_ENABLED
#define LOG_INFO_MSG(msg,...)
do{
printf("[%s:%d][Info] ",__FILE__,__LINE__);
printf(msg,(##__VA_ARGS__));
}while(0);
#else
#define LOG_INFO_MSG(msg,...)
#endif
#ifdef LOG_WARNING_MSG_ENABLED
#define LOG_WARNING_MSG(msg,...)
do{
printf("[%s:%d][Warning] ",__FILE__,__LINE__);
printf(msg,(##__VA_ARGS__));
}while(0);
#else
#define LOG_WARNING_MSG(msg,...)
#endif
#ifdef LOG_ERROR_MSG_ENABLED
#define LOG_ERROR_MSG(msg,...)
do{
printf("[%s:%d][Error] ",__FILE__,__LINE__);
printf(msg,(##__VA_ARGS__));
}while(0);
#else
#define LOG_ERROR_MSG(msg,...)
#endif
#endif //_CONFIG_LOG_H_
app_main.c:
c++
#include"config_log.h"
void foo(int level){
LOG_DEBUG_MSG("debug message...n");
LOG_INFO_MSG("info message...n");
LOG_WARNING_MSG("warning message...n");
LOG_ERROR_MSG("error message...n");
}
int main(void){
foo();
return ;
}
/*
gcc app_main.c config_log.h ……
*/
/*
gcc app_main.c config_log h ……….. #-DLOG_DEBUG_MESG_ENABLED #-DLOG_INFO_MESG_ENABLED #-DLOG_WARNING_MESG_ENABLED #-DLOG_ERROR_MESG_ENABLED .......
*/
/*
gcc app_main.c config_log h ……….. #-DLOG_DEBUG_MESG_ENABLED ...... ........
*/
/*
gcc app_main c config_log h ... ... ...
*/
/*
gcc app_main c config_log h ... ... ...
*/
/*
gcc app_main c config_log h ... ... ...
*/
###### 注意事项:
由于条件判断发生在预处理期间,
故需要确保相关变量已经在预处理期间声明好,
否则将出现类似“variable undeclared”的错误.
###### 内联函数:
内联函数即 inline 函数,
inline 函数虽然也属于普通普通宏,
但由于 inline 函数要求传递参数,
故 inline 函数具有更加灵活强大特性.
inline 函数只有在满足某些特殊条件才能够真正起效果,
否则 inline 函数跟普通普通宏没啥区别.
inline 函数必须遵循以下规则:
inline 函数必须放置在 header 文件里面;
inline 函数必须声明为 static;
inline 函数必须提供完整实现;
inline 标记必须放置在每个 inline 函数声明上;
inline 标记只能放置在 function declaration 上;
不能放置在 function definition 上;
不能放置在 function definition 外;
例子:
header_file:
c++
static inline void foo(int n){
if(n>=10){
n++;
}else{
n--;
}
}
extern void bar(int n); /* function declaration */
static void baz(int n); /* function definition */
static void baz(int n){
if(n>=10){
n++;
}else{
n--;
}
}
static void qux(int n); /* function declaration */
static inline void qux(int n){
if(n>=10){
n++;
}else{
n--;
}
}
void corge(int n); /* function declaration */
static inline void corge(int n){
if(n>=10){
n++;
}else{
n--;
}
}
void grault(int n); /* function declaration */
extern static inline void grault(int n){ /* error! */
if(n>=10){
n++;
}else{
n--;
}
}
/* error! */
extern static inline grault(int n);
/* error! */
extern static grault int n);
/* error! */
static inline grault(void);
void garply(); /* function declaration */
extern garply(); /* error! */
garply(); /* error! */
garply; /* error! */
void mumble(); /* function declaration */
extern mumble(); /* ok */
mumble(); /* ok */
mumble; /* ok */
static mumble(); /* error! */
static mumble; /* ok */
/* all below are ok */
extern mumble();
mumble();
mumble;
/* all below are not ok because they don't have complete definitions */
bar();
baz();
qux();
corge();
grault();
garply();
mumble();
/* all below are not ok because they don't have complete definitions or aren't marked as static or aren't marked as inline */
bar();
baz();
qux();
corge();
grault();
/* all below are ok because they're marked as both static & inline or just static or just marked as extern */
baz();
garply();
mumble();
app_main.cpp:
c++
#include"header_file"
int main(void){
int var = foo(var);
var = bar(var);
var = baz(var);
var = qux(var);
var = corge(var);
var = grault(var);//error!
var = garply();//error!
var = mumble();//ok!
return ;
}
/*
gcc app_main.cpp header_file ...
*/
/*
clang++ app_main.cpp header_file ...
*/
/*
clang++ app_main.cpp header_file ...
*/
注意事项:
对于静态链接库而言,
如果静态链接库中包含内联函数,
则需确保静态链接库提供完整实现,
同时需确保静态链接库内部不存在多余内联声明,
否则将导致连接失败.
对于共享链接库而言,
如果共享链接库中包含内联函数,
则需确保共享链接库提供完整实现,
同时需确保共享链接库内部不存在多余内联声明,
同时需确保客户端也提供完整实现,
同时需确保客户端也不存在多余内联声明,
否则将导致连接失败.
###### 替换限定:
替换限定即 replacement qualifiers ,
替换限定主要涉及四种修饰方式:
line-replacement qualifier : 即#line ,
line-replacement qualifier 可以让 preprocessor 改写行号,
stringification qualifier : 即 ## ,
stringification qualifier 可以让 preprocessor 把 token 转化为字符串,
trailing context qualifier : 即 __VA_ARGS__,
trailing context qualifier 可以让 preprocessor 改写尾部上文,
preprocessing number qualification : 即 ## ,
preprocessing number qualification 可以让 preprocessor 改写 token 数目.
例子:
config_header.hpp:
cpp
#ifndef CONFIG_HEADER_HPP_
#define CONFIG_HEADER_HPP_
#ifndef NDEBUG
//#define TRACE(...) fprintf(stderr,"(%s:%d):", __FILE__, __LINE__);fprintf(stderr,__VA_ARGS__)
//#define TRACE(...) fprintf(stderr,"(%s:%d):t",__FILE__, __LINE__);fprintf(stderr,__VA_ARGS__)
//#define TRACE(...) fprintf(stderr,#__VA_ARGS__, __FILE__, __LINE__)
//#define TRACE(...) fprintf(stderr,#__VA_ARGS__, ## __VA_ARGS__)
//#define TRACE(...) fprintf(stderr,#(__VA_ARGS__), ## __VA_ARGS__)
//#define TRACE(...) fprintf(stderr,#(__VA_ARGS__), ## __VA_ARGS__)
///brief trace macro which prints file name,line number,and arguments specified by user.
///param args user specified arguments.
///return none.
///note you should use it like TRACE(fmt,args).
///
///
///
///
///
///
///
//
//
//
//
//
/// def TRACE(args...)
/// brief trace macro which prints file name,line number,and arguments specified by user.
/// param args user specified arguments.
/// return none.
/// note you should use it like TRACE(fmt,args).
///
//#ifdef NDEBUG
////#undef NDEBUG
////#define NDEBUG
////#endif
///// def NDEBUG
///// brief define if we want disable trace macro .
///// return none
///// note you should use it like NDEBUG
////
////
////
////
////
////
////
////
////
////
//
//
//
//
//
/**
* @def NDEBUG
* @brief define if we want disable trace macro .
* @return none
* @note you should use it like NDEBUG
*
*
*
*
*
*
*
*
*
*
*/
//#ifdef NDEBUG
//#undef NDEBUG
//#endif
/**
* @def LINE
* @brief define current line number .
* @return none
* @note you should use it like LINE
*
*
*
*
*
*/
/**
* @def FILE_NAME
* @brief define current file name .
* @return none
* @note you should use it like FILE_NAME
*/
/**
* @def FUNC_NAME
* @brief define current funciton name .
* @return none
* @note you should use it like FUNC_NAME
*/
/**
*@fn FILE_NAME
*@brief define current file name .
*@return none
*@note you should use it like FILE_NAME
*/
/**
*@fn FUNC_NAME
*@brief define current funciton name .
*@return none
*@note you should use it like FUNC_NAME
*/
#ifndef LINE
#line
#line
#line
#line
#line
#line
#line
#line
#line
#line
#line
#line
#line
#elif defined(FILE_NAME)
#elif defined(FUNC_NAME)
#elif defined(LINE)
#elif defined(NDEBUG)
#elif defined(DEBUG)
#elif defined(_NDEBUG_)
#elif defined(_DEBUG_)
#else
#error please select one mode from above five modes !!!!!!!!
#error please select one mode from above five modes !!!!!!!!
#error please select one mode from above five modes !!!!!!!!
#error please select one mode from above five modes !!!!!!!!
#error please select one mode from above five modes !!!!!!!!
#error please select one mode from above five modes !!!!!!!!
#error please select one mode from above five modes !!!!!!!!
#error please select one mode from above five modes !!!!!!!!
#else
#endif
typedef struct {
char data[1024];
}buf_t;
typedef struct {
buf_t buf;
}trace_t;
trace_t g_trace;
char g_debug_msg[10240];
char g_warning_msg[10240];
char g_error_msg[10240];
char g_info_msg[10240];
const char msg[]="hello world";
const char msg[]="hello world";
const char msg[]="hello world";
const char msg[]="hello world";
const char msg[]="hello world";
const char msg[]="hello world";
const char msg[]="hello world";
const char msg[]="hello world";
const char msg[]="hello world";
template
T& operator<<(T& t,const U& u);
template
T& operator>>(T& t,U&& u);
template
T& operator<<(T& t,const U& u);
template
T& operator>>(T& t,U&& u);
template
T& operator<<(T& t,const U& u);
template
T& operator>>(T& t,U&& u);
template
typename std::enable_if::value,void>::type trace(T&& t,U&& u){}
template
