/*std*/实现mstring类

//实现mstring类,//未实现友元函数+,<<,>>  1 #include<cstring>
  2 #include<iostream>
  3 #include<istream>
  4 #include<ostream>
  5 class mstring{
  6     friend mstring& operator+(const mstring&str1,const mstring&str2);
  7     friend mstring& operator+(const char*str1,const mstring&str2);
  8     friend mstring& operator+(const mstring&str1,const char*str2);
  9     friend std::ostream&operator<<(std::ostream&os,const mstring&str);
 10     friend std::istream&operator>>(std::istream&is,mstring&str);
 11     public:
 12         mstring();
 13         mstring(char*str);
 14         mstring(const mstring& str);
 15         mstring(int n);
 16         ~mstring(){
 17             delete[]m_data;
 18         }
 19         mstring& operator=(char*str);
 20         mstring& operator=(const mstring&str);
 21         bool operator<(const mstring&str)const;
 22         bool operator>(const mstring&str)const;
 23         bool operator==(const mstring&str)const;
 24         void printf()const;
 25         int get_length()const{
 26             return strlen(m_data);
 27         }
 28         mstring substring(int i,int j)const;
 29     private:
 30         char*m_data;
 31
 32 };
 33
 34 mstring::mstring(){
 35     m_data=new char;
 36     *m_data=‘\0‘;
 37 }
 38 mstring::mstring(char*str){
 39     m_data=new char[strlen(str)+1];
 40     strcpy(m_data,str);
 41 }
 42 mstring::mstring(const mstring&str){
 43     m_data=new char[strlen(str.m_data)+1];
 44     strcpy(m_data,str.m_data);
 45 }
 46 mstring::mstring(int n){
 47     m_data=new char[n+1];
 48     int i=0;
 49     for(i=0;i<n;i++){
 50         m_data[i]=‘0‘;
 51     }
 52     m_data[n]=‘\0‘;
 53 }
 54 mstring& mstring::operator=(char*str){
 55     delete [] m_data;
 56     m_data=NULL;
 57     m_data=new char[strlen(str)+1];
 58     strcpy(m_data,str);
 59     return *this;
 60 }
 61 mstring& mstring::operator=(const mstring&str){
 62     if(this==&str) return *this;
 63     delete []m_data;
 64     m_data=NULL;
 65     m_data=new char[strlen(str.m_data)+1];
 66     strcpy(m_data,str.m_data);
 67     return *this;
 68 }
 69 bool mstring::operator<(const mstring&str)const{
 70     if(strcmp(this->m_data,str.m_data)<0) return true;
 71     else return false;
 72 }
 73 bool mstring::operator>(const mstring&str)const{
 74     if(strcmp(this->m_data,str.m_data)>0) return true;
 75     else return false;
 76 }
 77 bool mstring::operator==(const mstring&str)const{
 78 if(strcmp(this->m_data,str.m_data)==0) return true;
 79     else return false;
 80 }
 81
 82 //mstring operator+(const mstring&str1,const mstring&str2){}
 83
 84 //mstring operator+(const char*str1,const mstring&str2){}
 85
 86 //mstring operator+(const mstring&str1,const char*str2){}
 87
 88 //ostream&operator<<(ostream&str,const mstring&str){}
 89
 90 //istream&operator>>(istream&str,mstring&str){}
 91
 92 void mstring::printf()const{
 93     for(int i=0;m_data[i]!=0;i++){
 94                 std::cout<<m_data[i];
 95     }
 96     std::cout<<std::endl;
 97 }
 98
 99 mstring mstring::substring(int i,int j)const{
100     int strlength=strlen(this->m_data);
101     if(i>j||i>strlength-1||j<0){
102         mstring mtemp;
103         return mtemp;
104     }
105     if(i<0) i=0;
106     if(j>strlength-1) j=strlength-1;
107     mstring mtemp(j-i+1);
108     int index=0,k=0;
109     for(index=0;index<=strlength-1;index++){
110         if(index>=i&&index<=j)
111         {
112             mtemp.m_data[k++]=this->m_data[index];
113         }
114     }
115     return mtemp;
116 }
117
118 int main(){
119     mstring ms,ms2,ms3;
120     ms="adbc";
121     ms2=ms;
122     ms.printf();
123     ms2.printf();
124     std::cout<<ms.get_length();
125     std::cout<<std::endl;
126     ms3=ms2.substring(1,5);
127     ms3.printf();
128     return 0;
129 }
时间: 2024-11-08 21:32:50

/*std*/实现mstring类的相关文章

C++11 std::thread在类的成员函数中的使用

#include <thread> #include <iostream> class Wrapper { public: void member1() { std::cout << "i am member1" << std::endl; } void member2(const char *arg1, unsigned arg2) { std::cout << "i am member2 and my first

c++ -- 类

class A; 类成员: 1.函数成员 构造函数:一种特殊的成员函数,不能声明为const 的 常量指针this:this类型为“A *const”,总是指向调用成员函数的“这个”对象: const成员函数:用于修改隐式this指针的类型,修改后this指针类型为“const A *const”.相当于为this指针增加了“底层const”,能够引起重载: 返回this对象的函数: /*注意返回类型和返回语句*/ Sales_data & Sales_data::combine(const S

【C/C++学院】(11)泛型编程/函数模板/类模板

1.泛型编程基础 #include "iostream" using namespace std; void swap(int &a, int &b) { int c; c = a; a = b; b = c; } void swap(float &a, float &b) { float c; c = a; a = b; b = c; } void main() { int a = 1, b = 2; swap(a, b); float a1 = 1,

拷贝构造,深度拷贝,关于delete和default相关的操作,explicit,类赋初值,构造函数和析构函数,成员函数和内联函数,关于内存存储,默认参数,静态函数和普通函数,const函数,友元

 1.拷贝构造 //拷贝构造的规则,有两种方式实现初始化. //1.一个是通过在后面:a(x),b(y)的方式实现初始化. //2.第二种初始化的方式是直接在构造方法里面实现初始化. 案例如下: #include<iostream> //如果声明已经定义,边不会生成 class classA { private: int a; int b; public: //拷贝构造的规则,有两种方式实现初始化 //1.一个是通过在后面:a(x),b(y)的方式实现初始化 //2.第二种初始化的方式是直

C++——多线程编程(一)std::thread

(一)与C++11多线程相关的头文件 C++11 新标准中引入了四个头文件来支持多线程编程,他们分别是< atomic> ,< thread>,< mutex>,< condition_variable>和< future>. ?< atomic>:该头文主要声明了两个类, std::atomic 和 std::atomic_flag,另外还声明了一套 C 风格的原子类型和与 C 兼容的原子操作的函数. ?< thread>

std::decay

参考资料 • cplusplus.com:http://www.cplusplus.com/reference/type_traits/decay/ • cppreference.com:http://en.cppreference.com/w/cpp/types/decay std::decay简介 • 类模板声明 // cplusplus.com template <class T> struct decay; // MS C++ 2013template <class _Ty>

C++14使用std::integer_sequence展开tuple作为函数的参数

元组是一种长度固定的允许有不同类型元素的集合,根据元素的个数不同又分别称作一元组.二元组.三元组等.C++11中标准库增加了一个叫std::tuple的类模板,用于表示元组. 下面的代码演示了使用C++创建一个三元组. auto tuple = std::make_tuple(1, 'A', "test"); std::cout << std::get<0>(tuple) << std::endl; std::cout << std::g

一个参数处理类

在最近的项目中,使用的插件式架构, 插件的每个功能都需要用户输入的参数(所需的参数值配置在xml文件中),之前的做法是将每个功能需要的所有参数定义成结构体程序一开始,解析XML文件,将对应名称的参数值填充到相应的字段中.如果参数个数很多,则参数结构体的字段就会很多,写起来就会很麻烦,而且当某个模块新增参数时(在xml文件中添加),就必须修改参数结构体,不利于程序扩展.所以写了一个下面的参数类,将xml中所有参数按 参数名(string) 参数值(string)键值对的形式存储到map中,当需要某

回调函数的使用方法(类之间的通信)

// ConsoleApplication3.cpp : 定义控制台应用程序的入口点. // #include "stdafx.h" #include <iostream> #include <functional> using namespace std; //1 "方向盘" 类接收外部的操作, 把消息传到 "车" 类中, 车类把消息传入到 "轮子" 类上 //(子类发消息给父类) //2 "