C++编译期串

男娘i 2022-09-04 14:57 188阅读 0赞

串 日志串(常 符*文件名,整 行号){
       
      串视 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){
       
        静日志串(__文件__,至串(__行__));
      }
    }
    
    整 主(){
       
      测试日志串();
      测试静日志串();
      测试静日志串();
      测试日志串();
    }