C++编译期串

串 日志串(常 符*文件名,整 行号){
  串视 s(文件名);
  动 位置=s.右找('/');
  动 名=(位置==串视::几位置)?文件名:s.子串(位置+1);
  串流 ss;
  ss<<名<<":"<<行号<<":";
  中 ss.串();
}


动 s=日志串(__文件__,__行__);
输出<<"运行时日志"<<s<<"\n";//main.cpp:12
动 静日志串(常 编译时串&文件名,常 编译时串&行号){
  动 位置=文件名.右找('/');
  中 串.子串(位置+1)+":"+行号+":";
}
元<类 符,整 N>
类 固定串{...};

空 测试串(){
  常式 动 s1="你好"_fs;//FixedString<符, 5>
  常式 动 s=s1+""+"世界";
  //多了个常式.
  静断(s=="你好世界"_fs);
  静断(s.子串(4)=="世界"_fs);
}

//成员
元<类 符,整 N>
类 固定串{
  符 数据_[N+1];// +1 是为了放字符串终止符'0'
  整 大小_; // 这个size是不包含字符串终止符的长度, size_ <= N.
  //...
};

//构造
元<类 符,整 N>
类 固定串{
  符 数据_[N+1];// +1 是为了放字符串终止符'0'
  整 大小_; // 这个size是不包含字符串终止符的长度, size_ <= N.
公:
  元<类 那,整...是>
  常式 固定串(常 那&那,整 大小,引序<是...>,
    整 位置=0,整 数=几位置)无异
    :数据_{(是<(大小-位置)&&是<数?那[是+位置]:符(0))...,符(0)},
    大小_{最小(大小-位置,数)}{}
//序列,逗号表达式,列表初化
  常式 整 大小()常 无异{中 大小_;}
数据_{(是<(大小-位置)&&是<数?那[是+位置]:符(0))...,符(0)}//关键
//逗号表达式展开.也可以考虑用`折叠`表达式.

空 测试构造(){
  常式 常 符*串="你好";
  常式 固定串<符,4>固定串(串,4,造引序<4>{});
  //构造串,要计算串长度,还要`造序`.
  静断(固定串.大小()==4);//ok
}

常式 动 串="你好"_fs;//FixedString<符, 4>
//要这样提供
常式 动 1串=造固定串("你好");//或这样.
静断(串==1串);
  //支持符数组
//加几个构造函数的重载.
  元<整 M,类=型名 允许如<(M-1<=N)>::类型>
  常式 固定串(常 符(&那)[M])无异
    :固定串{那,M-1,造引序<M-1>{}}{}

  //指针符*
  常式 固定串(常 符*那,整 数)无异
    :固定串(那,数,造引序<N>{}){}
//有了上面,就可用编译期串常量来构建了
//仅对林操,微软不行,下面为辅助函数.
元<类 符,符...C>
常式 固定串<符,的大小...(C)>符号""_fs()无异{
  常 符 a[]={C...,符(0)};
  中{a,的大小...(C)};//调用支持符*的构造函数
}

元<类 符,整 N>
常式 固定串<符,N-1>造固定串(常 符(&a)[N])无异{
  中{a};//调用支持符数组的构造函数
}
//`+/=`操作符
  元<类 左,类 右,整...是>
  常式 固定串(常 左&左,整 左大小,常 右&右,
    整 合适大小,引序<是...>)无异
    :数据_{符在<符>(左,左大小,右,合适大小,是)...,符(0)},大小_{左大小+合适大小}{}
    //生成新`固定串`.
元<类 符,类 左,类 右>
常式 符 符在(常 左&左,整 左计数,常 右&右,整 右计数,整 i)无异{//返回哪个符.前半用左,后半用右
  中 i<左计数?左[i]
    :i<(左计数+右计数)?右[i-左计数]:符(0);
}
//实现连接
元<类 符,类 左,类 右,整...是>
静 常式 固定串<符,的大小...(是)>连接(
  常 左&左,整 左计数,常 右&右,整 右计数,
  引序<是...>是)无异{
  中{左,左计数,右,右计数,是};
}
//+符号.
元<整 M>友 常式 固定串<符,N+M-1>符号+(
    常 固定串&a,常 符(&b)[M])无异{
    中 连接<符>(a.数据_,a.大小_,b,M-1,造引序<N+M-1>{});
}//这个N是从`构`模板里面来的.

元<整 M>友 常式 固定串<符,N+M-1>符号+(
  常 符(&a)[M],常 固定串&b)无异{
    中 连接<符>(a,M-1,b.数据_,b.大小_,造引序<N+M-1>{});
}//两个+符号
//==操作符.
元<类 左,类 右>
常式 极 相等(常 左&左,整 左大小,常 右&右,
  整 合适大小)无异{
  如(左大小!=合适大小)中 假;
  对(整 i=0;i<左大小;++i){
    如(左[i]!=右[i])中 假;
  }
  中 真;
}

元<类 符,整 A,整 B>
常式 极 符号==(常 固定串<符,A>&a,
  常 固定串<符,B>&b)无异{
  中 相等(a,a.大小(),b,b.大小());
}

元<类 符,整 A,整 B>
常式 极 符号!=(常 固定串<符,A>&a,常 固定串<符,B>&b){
  中!(a==b);
}//不等
空 测试连接(){
  常式 动 s1=造固定串("你好");
  常式 动 s=s1+","+"世界";
  常式 动 s2=造固定串("你好,世界");
  静断(s==s2);
}
//用常式实现算法
  常式 整 大小()常 无异{中 大小_;}
  常式 整 长度()常 无异{中 大小_;}
  常式 极 空的()常 无异{中 0==大小_;}
  静 常式 整 容量()无异{中 N;}
  静 常式 整 最大大小()无异{中 N;}

  常式 符&在(整 i)无异(假){中 数据_[i];}
  常式 常 符&在(整 i)常 无异(假){中 数据_[i];}
  常式 符&符号[](整 i)无异{中 数据_[i];}
  常式 常 符&符号[](整 i)常 无异{中 数据_[i];}

  常式 符&前()无异{中(*本)[0];}
  常式 常 符&前()常 无异{中(*本)[0];}
  常式 符&后()无异{中 数据_[大小_-1];}
  常式 常 符&后()常 无异{中 数据_[大小_-1];}
  常式 空 清理()无异{
    数据_[0]=符(0);大小_=0;
  }
  常式 空 压后(符 c)无异(假){
    //检查溢出(1, N - size_);
    数据_[大小_]=c;
    数据_[++大小_]=符(0);
  }

  常式 空 弹后()无异(假){
    //检查溢出(1, size_);
    --大小_;数据_[大小_]=符(0);
  }

  元<整 M>
  常式 固定串&附加(常 固定串<符,M>&那)无异(假){
    中 附加(那,0,那.大小_);
  }

  元<整 M>
  常式 固定串&附加(常 固定串<符,M>&那,整 位置,整 数)无异(假){
    对(整 i=0;i<数;++i){
      数据_[大小_+i]=那.数据_[位置+i];
    }
    大小_+=数;
    数据_[大小_]=符(0);
    中*本;
  }

  常式 固定串&附加(常 符*那)无异(假){
    中 附加(那,串长(那));
  }

  常式 固定串&附加(常 符*那,整 数)无异(假){
    对(整 i=0;i<数;++i){
      数据_[大小_+i]=那[i];
    }
    大小_+=数;
    数据_[大小_]=符(0);
    中*本;
  }

  常式 整 找(符 c){
    对(整 i=0;i<N;++i){
      如(数据_[i]==c){
        中 i;
      }
    }

    中 几位置;
  }

  常式 整 右找(符 c){
    对(整 i=N-1;i>=0;--i){
      如(数据_[i]==c)中 i;
    }

    中 几位置;
  }

  常式 固定串 子串(整 位置)常 无异(假){
    中{*本,位置};
  }

  常式 固定串 子串(整 位置,整 数)常 无异(假){
    中{*本,位置,数};
  }

  常式 整 复制(符*汇,整 数,整 位置)常
    无异(假){
    对(整 i=0;i<数;++i){
      如(i+位置==大小_){
        中 大小_;
      }
      汇[i]=数据_[i+位置];
    }
    中 数;
  }
//至串,到串视
  符号 基串<符>()常 无异(假){
    中 基串<符>{开始(),尾()};
  }

  基串<符>至串()常 无异(假){
    中 基串<符>{开始(),尾()};
  }
  常式 符号 基本串视<符>()常{
    中 基本串视<符>{开始(),大小()};
  }
  基串<符>到串视()常 无异(假){
    中 基本串视<符>{开始(),尾()};
  }
//测试代码
空 测试至串(){
  常式 动 串=造固定串("你好");
  串 s=串;
  串视 s1=串;
  断定(s=="你好"s);
  断定(s1=="你好"sv);
}
元<整 N,整 M>
常式 动 静日志串(常 符(&文件名)[N],常 符(&行号)[M]){
  动 串=造固定串(文件名);
  动 位置=串.右找('/');
  中 串.子串(位置+1)+":"+行号+":";
}

#定义 串(x)#x
#定义 至串(x)串(x)

常式 动 s=静日志串(__文件__,至串(__行__));
输出<<s.数据()<<"\n";//main.cpp:20:
性能比较
空 测试日志串(){
  域计时器 计时器("哈哈");
  对(整 i=0;i<10000;++i){
    日志串(__文件__,__行__);
  }
}

#定义 串(x)#x
#定义 至串(x)串(x)

空 测试静日志串(){
  域计时器 计时器("新的");
  对(整 i=0;i<10000;++i){
    静日志串(__文件__,至串(__行__));
  }
}

整 主(){
  测试日志串();
  测试静日志串();
  测试静日志串();
  测试日志串();
}