运算符重载及组合与继承

最新推荐文章于 2023-12-12 18:54:59 发布
最新推荐文章于 2023-12-12 18:54:59 发布
阅读量578 收藏
点赞数 1
分类专栏： C++/QT 文章标签： 嵌入式 C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52479948/article/details/128690078
版权

目录

一、运算符重载

1.1普通运算符重载

1.2特殊运算符重载

二、标准输入输出流

三、组合与继承

3.1组合

3.2继承

1) public继承方式

2) protected继承方式

3) private继承方式

小作业：模仿c++的string类，自己实现string类

一、运算符重载

百度百科-验证

1.1普通运算符重载

//C++准许以运算符命名函数！！！
string  a = “hello”;
a += “ world”;// +(a, “world”);

cout<<“hello”;  //  <<(cout, “hello”);

可重载的运算符

 

不可重载的运算符

 

下面用一个例子来展示重载的妙处：

 

#include <stdio.h>
#include <unistd.h>
class Timer{
public:
    Timer()
    {
        hour = 0;
        min = 0;
        sec = 0;
    }
    ~Timer()
    {
        
    }
    void addtimer(int sec = 1)
    {
        this->min += (this->sec+sec)/60;
        this->sec = (this->sec + sec) % 60;
    }

    void show()
    {
        printf("%2d:%2d:%2d\n", hour, min, sec);
    }
private:
    int hour;
    int min;
    int sec;
};

int main()
{
    Timer t;
    while(1)
    {
        t.addtimer(1);
        t.show();
        sleep(1);
    }
}

 

如果我想向下面这样 

#include <stdio.h>
#include <unistd.h>
class Timer{
public:
    Timer()
    {
        hour = 0;
        min = 0;
        sec = 0;
    }
    ~Timer()
    {
        
    }
    void addtimer(int sec = 1)
    {
        this->min += (this->sec+sec)/60;
        this->sec = (this->sec + sec) % 60;
    }

    void show()
    {
        printf("%2d:%2d:%2d\n", hour, min, sec);
    }
private:
    int hour;
    int min;
    int sec;
};

int main()
{
    Timer t;
    t.addtimer(3);

    Timer t1;
    t1.addtimer(5);

    Timer t2;
    t2 = t + t1;
    t2.show();

#if 0
    while(1)
    {
        t.addtimer(1);
        t.show();
        sleep(1);
    }
#endif
}

 

 结果就是报错，但是他提醒我们可以重载

#include <stdio.h>
#include <unistd.h>
class Timer{
public:
    Timer()
    {
        hour = 0;
        min = 0;
        sec = 0;
    }
    ~Timer()
    {
        
    }
    void addtimer(int sec = 1)
    {
        this->min += (this->sec+sec)/60;
        this->sec = (this->sec + sec) % 60;
    }

    void show()
    {
        printf("%2d:%2d:%2d\n", hour, min, sec);
    }
    Timer operator+(Timer &x)
    {
        Timer tem;
        tem.sec = sec + x.sec;
        tem.min = min + x.min;
        tem.hour = hour + x.hour;
        return tem;
    }
private:
    int hour;
    int min;
    int sec;
};

int main()
{
    Timer t;
    t.addtimer(3);

    Timer t1;
    t1.addtimer(5);

    Timer t2;
    t2 = t + t1;
    t2.show();

#if 0
    while(1)
    {
        t.addtimer(1);
        t.show();
        sleep(1);
    }
#endif
}

 

#include <stdio.h>
#include <unistd.h>
class Timer{
public:
    Timer()
    {
        hour = 0;
        min = 0;
        sec = 0;
    }
    ~Timer()
    {
        
    }
    void addtimer(int sec = 1)
    {
        this->min += (this->sec+sec)/60;
        this->sec = (this->sec + sec) % 60;
    }

    void show()
    {
        printf("%2d:%2d:%2d\n", hour, min, sec);
    }
    Timer operator+(Timer &x)
    {
        Timer tem;
        tem.sec = sec + x.sec;
        tem.min = min + x.min;
        tem.hour = hour + x.hour;
        return tem;
    }
private:
    int hour;
    int min;
    int sec;
};

int main()
{
    Timer t;
    t.addtimer(3);

    Timer t1;
    t1.addtimer(5);

    Timer t2;
    t2 = t + t1;
    t2.show();
    t2 = t2 + 5;
    t2.show();

#if 0
    while(1)
    {
        t.addtimer(1);
        t.show();
        sleep(1);
    }
#endif
}

 

 这次又不行了，那就再重载一次。

#include <stdio.h>
#include <unistd.h>
class Timer{
public:
    Timer()
    {
        hour = 0;
        min = 0;
        sec = 0;
    }
    ~Timer()
    {
        
    }
    void addtimer(int sec = 1)
    {
        this->min += (this->sec+sec)/60;
        this->sec = (this->sec + sec) % 60;
    }

    void show()
    {
        printf("%2d:%2d:%2d\n", hour, min, sec);
    }
    Timer operator+(int sec)
    {
        Timer tem;
        tem.sec = this->sec + sec;
        return tem;
    }
    Timer operator+(Timer &x)
    {
        Timer tem;
        tem.sec = sec + x.sec;
        tem.min = min + x.min;
        tem.hour = hour + x.hour;
        return tem;
    }
private:
    int hour;
    int min;
    int sec;
};

int main()
{
    Timer t;
    t.addtimer(3);

    Timer t1;
    t1.addtimer(5);

    Timer t2;
    t2 = t + t1;
    t2.show();
    t2 = t2 + 5;
    t2.show();

#if 0
    while(1)
    {
        t.addtimer(1);
        t.show();
        sleep(1);
    }
#endif
}

 剩下的就都一样了，加减乘除对应换就行了

 

前++和后++不一样 

#include <stdio.h>
#include <unistd.h>
class Timer{
public:
    Timer()
    {
        hour = 0;
        min = 0;
        sec = 0;
    }
    ~Timer()
    {
        
    }
    void addtimer(int sec = 1)
    {
        this->min += (this->sec+sec)/60;
        this->sec = (this->sec + sec) % 60;
    }

    void show()
    {
        printf("%2d:%2d:%2d\n", hour, min, sec);
    }
    Timer operator+(int sec)
    {
        Timer tem;
        tem.sec = this->sec + sec;
        return tem;
    }
    Timer operator+(Timer &x)
    {
        Timer tem;
        tem.sec = sec + x.sec;
        tem.min = min + x.min;
        tem.hour = hour + x.hour;
        return tem;
    }

    Timer operator++(int)
    {
        Timer tem = *this;
        sec++;
        return tem;
    }
    Timer operator++()
    {
        sec++;
        return *this;
    }
private:
    int hour;
    int min;
    int sec;
};

int main()
{
    Timer t;
    t.addtimer(3);

    Timer t1;
    t1.addtimer(5);

    Timer t2;
    t2 = t + t1;
    t2.show();

    t2 = t2 + 5;
    t2.show();

    Timer t3 = t2++;
    t3.show();
    ++t3;
    t3.show();
#if 0
    while(1)
    {
        t.addtimer(1);
        t.show();
        sleep(1);
    }
#endif
}

 

 C++要求我们最好使用前++

因为后++需要先存一次，如果内容太大会很慢。

#include <stdio.h>
#include <unistd.h>
class Timer{
public:
    Timer()
    {
        hour = 0;
        min = 0;
        sec = 0;
    }
    ~Timer()
    {
        
    }
    void addtimer(int sec = 1)
    {
        this->min += (this->sec+sec)/60;
        this->sec = (this->sec + sec) % 60;
    }

    void show()
    {
        printf("%2d:%2d:%2d\n", hour, min, sec);
    }
    Timer operator+(int sec)
    {
        Timer tem;
        tem.sec = this->sec + sec;
        return tem;
    }
    Timer operator+(Timer &x)
    {
        Timer tem;
        tem.sec = sec + x.sec;
        tem.min = min + x.min;
        tem.hour = hour + x.hour;
        return tem;
    }

    Timer operator++(int)
    {
        Timer tem = *this;
        sec++;
        return tem;
    }
    Timer operator++()
    {
        sec++;
        return *this;
    }
    bool operator==(Timer &x)
    {
        if(sec == x.sec && min == x.min && hour == x.hour)
            return true;
        return false;
    }
private:
    int hour;
    int min;
    int sec;
};

int main()
{
    Timer t;
    t.addtimer(3);

    Timer t1;
    t1.addtimer(5);

    Timer t2;
    t2 = t + t1;
    t2.show();

    t2 = t2 + 5;
    t2.show();

    Timer t3 = t2++;
    t3.show();
    ++t3;
    t3.show();

    if(t2 == t3)
        printf("OK..time out!\n");
#if 0
    while(1)
    {
        t.addtimer(1);
        t.show();
        sleep(1);
    }
#endif
}

 

1.2特殊运算符重载

#include <stdio.h>
#include <unistd.h>
class Timer{
public:
    Timer()
    {
        hour = 0;
        min = 0;
        sec = 0;
    }
    ~Timer()
    {
        
    }
    void addtimer(int sec = 1)
    {
        this->min += (this->sec+sec)/60;
        this->sec = (this->sec + sec) % 60;
    }

    void show()
    {
        printf("%2d:%2d:%2d\n", hour, min, sec);
    }
    Timer operator+(int sec)
    {
        Timer tem;
        tem.sec = this->sec + sec;
        return tem;
    }
    Timer operator+(Timer &x)
    {
        Timer tem;
        tem.sec = sec + x.sec;
        tem.min = min + x.min;
        tem.hour = hour + x.hour;
        return tem;
    }

    Timer operator++(int)
    {
        Timer tem = *this;
        sec++;
        return tem;
    }
    Timer operator++()
    {
        sec++;
        return *this;
    }
    bool operator==(Timer &x)
    {
        if(sec == x.sec && min == x.min && hour == x.hour)
            return true;
        return false;
    }
    int operator[](int i)
    {
        switch(i)
        {
            case 0:
                return hour;
            case 1:
                return min;
            case 2:
                return sec;
        }
    }
private:
    int hour;
    int min;
    int sec;
};

int main()
{
    Timer t;
    t.addtimer(3);

    Timer t1;
    t1.addtimer(5);

    Timer t2;
    t2 = t + t1;
    t2.show();

    t2 = t2 + 5;
    t2.show();

    Timer t3 = t2++;
    t3.show();
    ++t3;
    t3.show();

    if(t2 == t3)
        printf("OK..time out!\n");
    printf("hour: %d\n", t2[0]);
    printf("min : %d\n", t2[1]);
    printf("sec : %d\n", t2[2]);

#if 0
    while(1)
    {
        t.addtimer(1);
        t.show();
        sleep(1);
    }
#endif
}

 如果返回的是对象就失去了左值的权利，（可以修改的值放到左边，所以左值就是修改值）

#include <stdio.h>
#include <unistd.h>
class Timer{
public:
    Timer()
    {
        hour = 0;
        min = 0;
        sec = 0;
    }
    ~Timer()
    {
        
    }
    void addtimer(int sec = 1)
    {
        this->min += (this->sec+sec)/60;
        this->sec = (this->sec + sec) % 60;
    }

    void show()
    {
        printf("%2d:%2d:%2d\n", hour, min, sec);
    }
    Timer operator+(int sec)
    {
        Timer tem;
        tem.sec = this->sec + sec;
        return tem;
    }
    Timer operator+(Timer &x)
    {
        Timer tem;
        tem.sec = sec + x.sec;
        tem.min = min + x.min;
        tem.hour = hour + x.hour;
        return tem;
    }

    Timer operator++(int)
    {
        Timer tem = *this;
        sec++;
        return tem;
    }
    Timer operator++()
    {
        sec++;
        return *this;
    }
    bool operator==(Timer &x)
    {
        if(sec == x.sec && min == x.min && hour == x.hour)
            return true;
        return false;
    }
    int &operator[](int i)
    {
        switch(i)
        {
            case 0:
                return hour;
            case 1:
                return min;
            case 2:
                return sec;
        }
    }
private:
    int hour;
    int min;
    int sec;
};

int main()
{
    Timer t;
    t.addtimer(3);

    Timer t1;
    t1.addtimer(5);

    Timer t2;
    t2 = t + t1;
    t2.show();

    t2 = t2 + 5;
    t2.show();

    Timer t3 = t2++;
    t3.show();
    ++t3;
    t3.show();

    if(t2 == t3)
        printf("OK..time out!\n");
    printf("hour: %d\n", t2[0]);
    printf("min : %d\n", t2[1]);
    printf("sec : %d\n", t2[2]);
    t2[1] = 30;
    printf("hour: %d\n", t2[0]);
	printf("min : %d\n", t2[1]);
	printf("sec : %d\n", t2[2]);
#if 0
    while(1)
    {
        t.addtimer(1);
        t.show();
        sleep(1);
    }
#endif
}

 接下来我们看看拷贝中运算符重载的妙用

 

#include <stdio.h>
#include <string.h>

class A{
public:
	A()
	{
		printf("A()\n");
		p = new char[10];
		strcpy(p, "hello");


		printf("p: %s\n", p);
		printf("p: %s\n", this->p);
	}

	A(const A &x)
	{
		printf("A(const A &x)\n");
		p = new char[10];
		strcpy(p, x.p);	
	}

	~A()
	{
		printf("~A()\n");
		delete [] p;
	}
#if 0
	A &     operator=(A &x)
	{
		printf("operator=\n");
		p = new char[10];
		strcpy(p, x.p);	
		return *this;
	}
#endif
private:
	char *p;
};

int main()
{
	A x;

	A y = x;


	y = x;
}

去掉注释部分

先学点快捷方式     3yy复制三行

接下来是（）这里我们引出仿函数

#include <iostream>
using namespace std;

int main()
{
//    std::cout<<"hello"<<std::endl;
    cout<<"hello"<<endl;
}

 

 

#include <iostream>

using namespace std;

class Converter{
public:
	Converter(double rate)
	{
		this->rate = rate;
	}

	double operator()(double rmb)
	{
		return rmb*rate;
	}
private:
	double rate;
};


double RMBto(double rmb, double rate)
{
	return rmb*rate;
}

int main()
{
//	std::cout << "hello"<<std::endl;
//	cout << "hello"<<endl;

	Converter RMBtoUS(6.4);
	cout << RMBtoUS(10) << endl;
	cout << RMBtoUS(10) << endl;
	cout << RMBtoUS(10) << endl;
	cout << RMBtoUS(10) << endl;
	cout << RMBtoUS(10) << endl;
	cout << RMBtoUS(10) << endl;
	cout << RMBtoUS(10) << endl;
	cout << RMBtoUS(10) << endl;

	Converter RMBtoE(8.4);
	cout << RMBtoE(100) << endl;
	cout << RMBtoE(100) << endl;
	cout << RMBtoE(100) << endl;
	cout << RMBtoE(100) << endl;
	cout << RMBtoE(100) << endl;
	cout << RMBtoE(100) << endl;
#if 0
	cout << RMBto(10, 6.4) << endl;
	cout << RMBto(10, 6.4) << endl;
	cout << RMBto(10, 6.4) << endl;
	cout << RMBto(10, 6.4) << endl;
	cout << RMBto(10, 6.4) << endl;
	cout << RMBto(10, 6.4) << endl;
	cout << RMBto(10, 6.4) << endl;
	cout << RMBto(10, 6.4) << endl;
	cout << RMBto(10, 6.4) << endl;
	cout << RMBto(10, 6.4) << endl;
	cout << RMBto(10, 6.4) << endl;
	cout << RMBto(10, 6.4) << endl;
	cout << RMBto(10, 6.4) << endl;
	cout << RMBto(10, 8.4) << endl;
	cout << RMBto(10, 8.4) << endl;
	cout << RMBto(10, 8.4) << endl;
	cout << RMBto(10, 8.4) << endl;
	cout << RMBto(10, 8.4) << endl;
	cout << RMBto(10, 8.4) << endl;
	cout << RMBto(10, 8.4) << endl;
	cout << RMBto(10, 8.4) << endl;
	cout << RMBto(10, 8.4) << endl;
	cout << RMBto(10, 8.4) << endl;
#endif
}

 百度百科-验证

接下来是对输出运算符的重载

比如直接输出一个对象

 

#include <stdio.h>
#include <unistd.h>
#include <iostream>

using namespace std;
class Timer{
public:
    Timer()
    {
        hour = 0;
        min = 0;
        sec = 0;
    }
    ~Timer()
    {
        
    }
    void addtimer(int sec = 1)
    {
        this->min += (this->sec+sec)/60;
        this->sec = (this->sec + sec) % 60;
    }

    void show()
    {
        printf("%2d:%2d:%2d\n", hour, min, sec);
    }
    Timer operator+(int sec)
    {
        Timer tem;
        tem.sec = this->sec + sec;
        return tem;
    }
    Timer operator+(Timer &x)
    {
        Timer tem;
        tem.sec = sec + x.sec;
        tem.min = min + x.min;
        tem.hour = hour + x.hour;
        return tem;
    }

    Timer operator++(int)
    {
        Timer tem = *this;
        sec++;
        return tem;
    }
    Timer operator++()
    {
        sec++;
        return *this;
    }
    bool operator==(Timer &x)
    {
        if(sec == x.sec && min == x.min && hour == x.hour)
            return true;
        return false;
    }
    int &operator[](int i)
    {
        switch(i)
        {
            case 0:
                return hour;
            case 1:
                return min;
            case 2:
                return sec;
        }
    }
    friend ostream &operator<<(ostream &out, const Timer &t);
private:
    int hour;
    int min;
    int sec;
};

ostream &operator<<(ostream &out, const Timer &t)
{
    out << "hour:" << t.hour << "min:" <<t.min<<"sec:" <<t.sec<<endl;
}

int main()
{
    Timer t;
    t.addtimer(3);

    Timer t1;
    t1.addtimer(5);

    Timer t2;
    t2 = t + t1;
    t2.show();

    t2 = t2 + 5;
    t2.show();

    Timer t3 = t2++;
    t3.show();
    ++t3;
    t3.show();

    if(t2 == t3)
    printf("OK..time out!\n");
    printf("hour: %d\n", t2[0]);
    printf("min : %d\n", t2[1]);
    printf("sec : %d\n", t2[2]);
    t2[1] = 30;
    printf("hour: %d\n", t2[0]);
	printf("min : %d\n", t2[1]);
	printf("sec : %d\n", t2[2]);

    cout<<t2;
#if 0
    while(1)
    {
        t.addtimer(1);
        t.show();
        sleep(1);
    }
#endif
}

二、标准输入输出流

 

#include <stdio.h>
#include <iostream>

using namespace std;

int main()
{
    //printf("input:");fflush(stdout);
    cout<<"input:";

    char buf[100];
    //gets(buf);
    cin >> buf;

    //printf("%s\n", buf);
    cout << buf <<endl;
}

它会自动识别，不像C那样%d %s %C 什么的

 

#include <stdio.h>
#include <iostream>

using namespace std;

int main()
{
    //printf("input:");fflush(stdout);
    cout<<"input:";

    char buf[100];
    //gets(buf);
    cin >> buf;

    //printf("%s\n", buf);
    cout << buf <<endl;

    cout<<10<<endl;
    cout <<hex<<10<<endl;

}

 

 

控制符

作 用

dec

设置数值的基数为10

hex

设置数值的基数为16

oct

设置数值的基数为8

setfill(c)

设置填充字符c，c可以是字符常量或字符变量

setprecision(n)

设置浮点数的精度为n位。在以一般十进制小数形式输出时，n代表有效数字。在以fixed(固定小数位数)形式和 scientific(指数)形式输出时，n为小数位数

setw(n)

设置字段宽度为n位

setiosflags( ios::fixed)

设置浮点数以固定的小数位数显示

setiosftags( ios::scientific)

设置浮点数以科学记数法(即指数形式)显示

setiosflags( ios::left)

输出数据左对齐

setiosflags( ios::right)

输出数据右对齐

setiosflags( ios::skipws)

忽略前导的空格

setiosflags( ios::uppercase)

数据以十六进制形式输出时字母以大写表示

setiosflags( ios::lowercase)

数据以十六进制形式输出时宇母以小写表示

setiosflags(ios::showpos)

输出正数时给出“+”号


需要注意的是： 如果使用了控制符，在程序单位的开头除了要加iostream头文件外，还要加iomanip头文件。

 

流成员函数

与之作用相同的控制符

作用

precision(n)

setprecision(n)

设置实数的精度为n位

width(n)

setw(n)

设置字段宽度为n位

fill(c)

setfill(c)

设置填充宇符c

setf()

setiosflags()

设置输出格式状态，括号中应给出格式状态，内容与控制符setiosflags括号中的内容相同，如表13.5所示

unsetf()

resetioflags()

终止已设置的输出格式状态，在括号中应指定内容

 

格式标志

作用

ios::left

输出数据在本域宽范围内向左对齐

ios::right

输出数据在本域宽范围内向右对齐

ios::internal

数值的符号位在域宽内左对齐，数值右对齐，中间由填充字符填充

ios::dec

设置整数的基数为10

ios::oct

设置整数的基数为8

ios::hex

设置整数的基数为16

ios::showbase

强制输出整数的基数(八进制数以0打头，十六进制数以0x打头)

ios::showpoint

强制输出浮点数的小点和尾数0

ios::uppercase

在以科学记数法格式E和以十六进制输出字母时以大写表示

ios::showpos

对正数显示“+”号

ios::scientific

浮点数以科学记数法格式输出

ios::fixed

浮点数以定点格式(小数形式)输出

ios::unitbuf

每次输出之后刷新所有的流

ios::stdio

每次输出之后清除stdout, stderr

 

三、组合与继承

 

 

 

3.1组合

一个类的功能都是依据另一个类的对象实现的，就是组合。 

3.2继承

 

#include <iostream>

using namespace std;

class A{
public:
    A(){ }
    ~A(){ }
    void showx()
    {
        cout<<"xxxxxxxxxxxxxxxxxxx"<<endl;
    }
};

class AX:public A{
public:
    void showy()
    {
        cout << "yyyyyyyyyyyyyyyyyyyyyyyyy"<<endl;
    }

};

int main()
{
    A a;
    a.showx();

    AX b;
    b.showx();
    b.showy();
}

然后再回到我们想写的学生管理系统，我们想要再加一个求平均值的功能，那么前面那种组合的方式就不能满足了。

#include "arr.h"
#include <iostream>

using namespace std;

class ARRX:public ARR{
public:
	int ever(void)
	{
		int i = 0;
		int sum = 0;
		for(;i<tail; i++)
			sum += data[i]; 
		return sum/tail;
	}
};

class Stuma{
public:
	Stuma(){

	}
	~Stuma() { }
	
	void savescore(int score)
	{
		scorearr.addtail(score);
	}
	
	int everscore(void)
	{
		return scorearr.ever();
	}

	void showscore(void)
	{
		scorearr.show();
	}

private:
	//ARR scorearr;
	ARRX scorearr;
};

int main()
{
	Stuma mmm;

	mmm.savescore(23);
	mmm.savescore(44);
	mmm.savescore(55);
	mmm.savescore(23);

	mmm.showscore();
	cout << mmm.everscore() <<endl;
}

 

1) public继承方式

  • 基类中所有public成员在派生类中为public属性；
  • 基类中所有protected成员在派生类中为protected属性；
  • 基类中所有private成员在派生类中不可访问。


2) protected继承方式

  • 基类中的所有public成员在派生类中为protected属性；
  • 基类中的所有protected成员在派生类中为protected属性；
  • 基类中的所有private成员在派生类中仍然不可访问。


3) private继承方式

  • 基类中的所有public成员在派生类中均为private属性；
  • 基类中的所有protected成员在派生类中均为private属性；
  • 基类中的所有private成员在派生类中均不可访问。

小作业：模仿c++的string类，自己实现string类

百度百科-验证

        能够准确无误地编写出String类的构造函数、拷贝构造函数、赋值函数和析构函数的面试者至少已经具备了C++基本功的60%以上！在这个类中包括了指针类成员变量m_data，当类中包括指针类成员变量时，一定要重载其拷贝构造函数、赋值函数和析构函数，这既是对C++程序员的基本要求，也是《Effective　C++》中特别强调的条款。仔细学习这个类，特别注意加注释的得分点和加分点的意义，这样就具备了60%以上的C++基本功！

我暂时不需要会这么多，就按会60%的标准写这四个，看了两个大佬写的比较全，连接放这，需要的自己去看看：

模拟实现C++中的string类(详细解析)_二肥是只大懒蓝猫的博客-CSDN博客

C++ string类模拟实现_全貌的博客-CSDN博客_模仿c++的string类,自己实现string类

#include <stddef.h>
#include <algorithm>
#include <iostream>
#include <string.h>

//using namespace std;

class String{
public:
    String()
    {
        _str = new char[1];
        _size = 0;
        _capacity = 0;
        _str[0] = '\0';
    }

    String(char* str)
    {
        _size = strlen(str);
        _capacity = _size;
        _str = new char[_capacity + 1];
        strcpy(_str, str);
    }
    ~String()
    {
        delete[] _str;
        _size = 0;
        _capacity = 0;
    }
    void swap(String& tmp)
//这是自己定义的交换函数，第一个参数是隐含的this指针，交换两个类的成员变量
	{
		std::swap(_str, tmp._str);//加::操作符表示调用的是全局的swap函数
		//_str和tmp._str都是指针,交换指向的空间的地址
		std::swap(_size, tmp._size);
		std::swap(_capacity, tmp._capacity);
	}
    
	//拷贝构造的传统写法
	String(String& s)
    {
		_str = new char[s._capacity + 1];
		_capacity = s._capacity;
		_size = s._size;
		strcpy(_str, s._str);
	}

    String& operator=(String& s)
    //使用传值传参，调用拷贝构造创建临时类s接收需要赋值的string类
	{
        if (this != &s)
        {
            String tmp(s);
		    swap(s);//交换它们
        }
		return *this;//返回this指向的类
	}//结束时临时类s销毁，自动调用析构函数
private:
    char* _str;
    size_t _size;           //long long unsigned int
    size_t _capacity;
};
int main()
{
    
}
宇努力学习
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
关于C++赋值运算符能不能继承问题
徐小小小hi的博客
03-30 3214
C++的赋值运算符是可以被继承的。 有的人说不能被继承，“赋值运算符重载函数”不是不能被派生类继承，而是被派生类的默认“赋值运算符重载函数”给覆盖了。 条款45:弄清C++在幕后为你所写、所调用的函数 一个空类什么时候不是空类？----当C++编译器通过它的时候。如果你没有声明下列函数，体贴的编译器会声明它自己的版本。这些函数是：一个拷贝构造函数，一个赋值运算符，一个析构函数，一对取址
方法的重写（继承内容）
qdyones的博客
12-15 470
#第一版：（正常输出 ） ##父类 package base.oop.Demo06; //父类 //重写都是方法的重写，和属性无关 public class B { public static void test() { System.out.println("B=>test()"); } } ##子类 package base.oop.Demo06; //子类 public class A extends B{ public static void
c++(继承)
weixin_67993841的博客
04-21 1270
c++继承的问题
C++复习（继承，运算符）
12-25 1028
----------------------继承: ,,,,(俺要主攻uc,还要回珠海工作) 1.子类继承父类方式：1.public 2.protected 3.private  通过public继承下来的，都不变  通过protected继承下来的，原有父类的public函数，将转化为protected来继承。  通过private继承下来的，原有父类的public ,protecte
C++:运算符重载及继承
最新发布
lmf1751014911的博客
12-12 865
前面学到了函数的重载，现在又新出现一个叫运算符重载的东西，还有C++三大特性之一的继承又是如何实现，起什么作用的呢？本文介绍了运算符重载的相关概念及代码呈现，如有不足，还望指出。
C++运算符重载和继承
qq_43718691的博客
03-11 1806
一、运算符重载 概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型 1.1加号运算符重载 作用：实现两个自定义数据类型相加的运算 编译器给起一个通用的名称——可以通过成员函数重载、或者通过全局函数重载 使用的的指令是：operator+ 总结：1、对于内置的数据类型的表达的运算符是不可能改变的 2、不要滥用运算符重载 1.2左移运算符重载（<<） 作用：可以输出自定义数据类型（一般是使用全局运算符重载） 1.3递增运算符重载 作用：通过重载递增运算符实
简单了解C++语言中的二元运算符和赋值运算符
01-20
逻辑运算符用于组合布尔值。重载这些运算符可能较少见，因为它们通常用于基本类型，但在特定情况下可能有用。 5. 赋值运算符：`=`, 在C++中，赋值运算符是一种特殊的二元运算符，它的功能是将右侧的值赋给左侧的...
C++ 编程思想 象的演化、数据抽象、隐藏实现、初始化与清除、函数重载与缺省参数、输入输出流介绍、常量、内联函数、命名控制、引用和拷贝构造函数、运算符重载、动态对象创建、继承和组合、多态和虚函数、模板和包容器类、多重继承、异常处理和运行时类型识别
01-04
全书共分十八章，内容涉及对象的演化、数据抽象、隐藏实现、初始化与清除、函数重载与缺省参数、输入输出流介绍、常量、内联函数、命名控制、引用和拷贝构造函数、运算符重载、动态对象创建、继承和组合、多态和虚...
c++语言新增的约定 符号名称与运算符
02-17
3. **运算符重载**：C++允许用户为已有的运算符赋予新的含义，这在处理自定义数据类型时非常有用。C语言中不支持这一特性。 4. **模板**：C++的模板机制允许我们编写泛型代码，实现数据类型的参数化。C语言中，要...
C++考试题库及答案精简.doc
11-30
本资源为C++考试题库及答案精简，涵盖了C++语言的基础知识点，包括变量、数据类型、函数、类和对象、继承、运算符重载等方面的知识点。 1. 能作为 C++程序的基本单位是函数（C）。在C++中，函数是程序的基本单位，...
CC++程序设计学习与实验系统.zip
06-03
3. 运算符与表达式：C++提供了丰富的运算符，如算术运算符、比较运算符、逻辑运算符等，以及如何组合这些运算符形成表达式。 二、控制流程 1. 顺序结构：程序按语句的顺序执行。 2. 分支结构：if语句和switch语句...
C++运算符重载(7) - 赋值操作符能否被继承?可以
alex1997222的博客
11-20 1429
赋值操作符也可以被继承。 基类的操作符可以被子类访问使用 例子如下 #include using namespace std; //操作符能否被继承?? class A { public: A& operator=(const A& obj) { cout << "the = operator called!" << endl; return *this; } }; cla
继承、运算符重载、多态、指针
xiehanhust的博客
07-25 305
指针，继承，多态
6、运算符重载、继承(C++核心语法)
伍粟的博客
04-14 395
1 关系运算符重载 1.1 对于自定义数据类型，编译器不知道如果进行比较 1.2 重载 == ！=号 1.3 bool operator==( Person & p) 1.4 bool operator!=(Person & p) #define _CRT_SECURE_NO_WARNINGS #include<iostream> using namespace std; class Person { public: Person(string name, int a
坚持学习100天：特殊运算符的重载
m0_55732114的博客
05-04 531
前言 Hello,我是修齊。 学习C++的第一百零一十三天,五一放假，忙起来没休息好，断了两天，继续吧。 在这里记录一些学习的东西和学习的心情,内容主要是一些自己学习整理的小笔记。 一、++ 和 – 1.不分前置和后置：operator++（）、operator–（） 2.重载前置运算符：operator++（）、operator–（） 3.重载后置运算符：operator++（int）、operator–（int）,调用时，参数int被传递给值0。 二、= 若没有自定义的赋值运算符函数，系统自动生成默认
几个特殊的运算符重载（前置\后置++、前置\后置--、＜＜、＞＞）
潜心钻研技术
01-12 663
运算符重载是一个非常重要的概念，在运算符重载中我们可以重新定义 运算符 的具体含义，一个运算符重载函数的定义是，对于运算符重载有以下重点。以下讨论的都是双操作数的运算符a+b;
C++运算符重载和继承问题
Yyds12300的博客
04-17 238
赋值运算符重载 重载是对类型的变量进行运算操作 int main() { person p1; person p2; person p3=p1+p2; } c++至少自动给一个类添加4哥函数 默认构造函(无参，函数体为空) 默认构造析构函数(无参，函数体为空) 默认拷贝构造函数，对属性进行拷贝 赋值与算法operator=,对属性进行值拷贝 赋值运算符也对属性进行拷贝操作。涉及深拷贝问题
C++ 重载运算符 继承 多态 （超详细）
日拱一卒,功不唐捐
06-22 4248
（一）重载运算符： （1）声明与定义格式 一般是类内声明，类外定义，虽然可以在类内定义，但 写前面堆一堆不好看！！！ 类内声明： class Demo { 返回值类型 operator 运算符（形参表）； } 类外定义： 返回类型 Demo（类名）：：operator运算符（形参表） { 函数体 } (2）双目运算符重载为成员函数 当重载运算符为双目运算符时，形参表中只有一个参数...
特殊运算符以及运算符的重载
yokan_de_s的博客
05-06 207
溢出运算符 目前的溢出运算符有三种&+ &- &* var num:Int8 = 127 print(Int8.max) //127 print(Int8.min) //-128 num += 1 print(num) //抛出异常 正常做运算如果溢出就会报错,比如上述代码,Int8支持的最大数字是127,再加1就溢出了,系统会抛出异常，解决办法就是用溢出运算符&+ var num:Int8 = 127 print(Int8.max) //127 pri
C++运算符重载与友元函数讲解
4. **类与对象**：引入面向对象编程的核心概念，如类、对象、构造函数、析构函数、类的组合以及类模板，这些都是C++中的核心特性，用于构建复杂的数据结构和模块化代码。 5. **其他高级主题**：课程可能还涵盖了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

宇努力学习

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值