C/C 语言是一种通用的编程语言，具有高效、灵活和可移植等特点。C语言主要用于系统编程，如操作系统、编译器、数据库等；C语言是C语言的扩展，增加了面向对象编程的特性，适用于大型软件系统、图形用户界面、嵌入式系统等。C/C 语言具有很高的效率和控制能力，但也需要开发人员自行管理内存等底层资源，对于初学者来说可能会有一定的难度。
实现函数重载: 函数重载是C 语言区别于C语言的重要特性,重载就是定义名称相同但符号或后面参数不同的函数,当重载时,编译器会偷偷在相同函数名的前面加上_func关键字字段,以此来实现重载后函数名不重复,通过编译检查.
#include <iostream>
using namespace std;
int func(int x) { return x; }
int func(int x, int y) { return x y; }
double func(double x, double y) { return x y; }
int main(int argc, char *argv[])
{
int ret1 = func(10);
int ret2 = func(100, 200);
double ret3 = func(10.5, 20.4);
cout << ret1 << ret2 << ret3 << endl;
system("pause");
return 0;
}重载与仿函数: 仿函数就是伪函数,一般情况下仿函数需要配合()重载小括号,来实现类似函数调用一样的语法.
代码语言：c复制#include <iostream>
#include <string>
using namespace std;
class MyPrint
{
public: void operator()(string text)
{
cout << text << endl;
}
};
class MyAdd
{
public: int operator()(int x, int y)
{
return x y;
}
};
int main(int argc, char *argv[])
{
MyPrint print;
print("hello lyshark"); // 使用仿函数
cout << MyAdd()(100, 200) << endl; // 匿名仿函数
system("pause");
return 0;
}重载加号运算符: 重载加号运算符,类p3 = p1 p2重载后等于p3.m_x = p1.m_x p2.m_x两个数据成员相加.
#include <iostream>
#include <string>
using namespace std;
class Person
{
public:
int m_x;
int m_y;
public:
Person(){};
Person(int x, int y) :m_x(x), m_y(y) {}
// 加号运算符重载,这里其实是二元,因为隐藏了一个this指针.
Person operator (Person &p)
{
Person tmp;
tmp.m_x = this->m_x p.m_x;
tmp.m_y = this->m_y p.m_y;
return tmp;
}
};
int main(int argc, char *argv[])
{
Person p1(10, 40);
Person p2(20, 90);
// 此处相当于 p1(10) p2(20) / p1(40) p2(90)
Person p3 = p1 p2;
cout << "p3 m_x = > " << p3.m_x << endl;
cout << "p3 m_y = > " << p3.m_y << endl;
system("pause");
return 0;
}重载全局函数: 重载运算符可以定义在一个类的内部,也可以定义在类外,定义在类外的则属于全局重载函数.
代码语言：c复制#include <iostream>
using namespace std;
class Person
{
public:
int m_x;
int m_y;
public:
Person(){};
Person(int x, int y) :m_x(x), m_y(y) {}
};
// 全局函数实现运算符重载，这个就属于二元运算符重载
Person operator (Person &p1, Person &p2)
{
Person tmp;
tmp.m_x = p1.m_x p2.m_x;
tmp.m_y = p1.m_y p2.m_y;
return tmp;
}
int main(int argc, char *argv[])
{
Person p1(10, 30);
Person p2(20, 50);
Person p3 = p1 p2;
cout << "p3 m_x = > " << p3.m_x << endl;
cout << "p3 m_y = > " << p3.m_y << endl;
system("pause");
return 0;
}重载左移运算符: 使用<<重载左移运算符,让cout直接输出两个变量,重载左移运算符不可以写成成员函数.
#include <iostream>
#include <string>
using namespace std;
class Person
{
friend ostream& operator<<(ostream &cout, Person &ptr);
private:
int m_x;
int m_y;
public:
Person(){};
Person(int x, int y) :m_x(x), m_y(y) {}
};
ostream& operator << (ostream &cout, Person &ptr)
{
cout << "m_x = " << ptr.m_x << " ----> " << "m_y = " << ptr.m_y << endl;
return cout;
}
int main(int argc, char *argv[])
{
Person p1(10, 30);
Person p2(20, 10);
cout << p1 << endl;
cout << p2 << endl;
system("pause");
return 0;
}重载自增/自减运算符: 自增运算符有两种形式第一种是前置自增运算符,这一种需要定义为MyInteger& operator (),而后自增运算符则需要增加一个int占位符MyInteger operator (int)这样编译器才会分得出来是重载前还是后.
#include <iostream>
#include <string>
using namespace std;
class MyInteger
{
friend ostream& operator<<(ostream& cout, MyInteger & myInt);
public:
int m_count;
public:
MyInteger() { m_count = 0; }
// 重载前置 x 运算符
MyInteger& operator ()
{
this->m_count ;
return *this;
}
// 重载后置 x 运算符,为了区分前后置,需要在参数后面增加一个int占位符
// 此时编译器才会认为我们需要使用后置重载运算符了
MyInteger operator (int)
{
MyInteger tmp = *this;
m_count ;
return tmp;
}
};
ostream& operator<<(ostream& cout, MyInteger & myInt)
{
cout << myInt.m_count;
return cout;
}
int main(int argc, char *argv[])
{
MyInteger myInt;
cout << myInt << endl;
cout << myInt << endl;
cout << ( myInt) << endl;
system("pause");
return 0;
}重载指针运算符(智能指针): 智能指正用来托管自定义的对象,让对象可以自动的释放数据,当我们使用一个对象结束以后,无需手动释放堆空间,智能指针会帮助我们完成这个过程.
代码语言：c复制#include <iostream>
#include <string>
using namespace std;
class Student
{
public:
char *m_name;
int m_age;
public:
Student(char *name, int age)
{
this->m_name = name;
this->m_age = age;
}
void Print()
{
cout << "Name: " << this->m_name << endl;
cout << "Age: " << this->m_age << endl;
}
};
// 定义智能指针,用于自动释放对象所占用的空间
class Smart_Pointer
{
private:
Student *ptr;
public:
// 先来执行构造函数,将传入的指针复制到内部
Smart_Pointer(Student *ptr)
{ this->ptr = ptr; }
// 重载运算符 -> 让智能指针能够直接指向Student
Student * operator -> ()
{ return this->ptr; }
// 重载运算符 *
Student & operator * ()
{ return *this->ptr; }
// 定义析构函数,这是智能指针的关键部分,对象会被自动释放
~Smart_Pointer()
{
if (this->ptr != NULL)
{
delete this->ptr;
this->ptr = NULL;
}
}
};
int main(int argc, char *argv[])
{
// 手动释放的案例：平常的使用方式
Student *stu = new Student("lyshark", 10);
stu->Print();
delete stu;
// 使用智能指针：则无需考虑释放的问题
Smart_Pointer ptr(new Student("lyshark", 10));
ptr->Print();
(*ptr).Print();
system("pause");
return 0;
}重载赋值运算符: 我们将等于号进行重载,实现对类中数据成员的赋值拷贝.
代码语言：c复制#include <iostream>
#include <string>
using namespace std;
class Student
{
public:
int m_uid;
char *m_name;
public:
Student(int uid, char *name)
{
this->m_uid = uid;
this->m_name = new char[strlen(name) 1];
strcpy(this->m_name, name);
}
// 重载 = 实现类数据成员的赋值运算
Student& operator = (const Student &ptr)
{
// 先来判断原来的堆区是否有内容,如果有则先来释放
if (this->m_name != NULL)
{
this->m_uid = 0;
delete[] this->m_name;
this->m_name = NULL;
}
// 否则，我们直接开辟空间完成内存拷贝
this->m_name = new char[strlen(ptr.m_name) 1];
strcpy(this->m_name, ptr.m_name);
this->m_uid = ptr.m_uid;
return *this;
}
// 析构函数,则需要释放内存
~Student()
{
if (this->m_name != NULL)
{
this->m_uid = 0;
delete[] this->m_name;
this->m_name = NULL;
}
}
};
int main(int argc, char *argv[])
{
Student stu1(1,"lyshark");
Student stu2(2, "admin");
Student stu3(0, "");
stu3 = stu2 = stu1;
cout << stu3.m_name << endl;
cout << stu2.m_name << endl;
cout << stu1.m_name << endl;
system("pause");
return 0;
}重载关系运算符: 重载关系运算符则可以实现两个类对象的直接对比.
代码语言：c复制#include <iostream>
#include <string>
using namespace std;
class Student
{
public:
int m_uid;
char * m_name;
public:
Student(int uid,char *name)
{
this->m_uid = uid;
this->m_name = name;
}
bool operator == (Student &ptr)
{
if (this->m_uid == ptr.m_uid && this->m_name == ptr.m_name)
return true;
return false;
}
bool operator != (Student &ptr)
{
if (this->m_uid != ptr.m_uid && this->m_name != ptr.m_name)
return true;
return false;
}
};
int main(int argc, char *argv[])
{
Student stu1(1, "lyshark");
Student stu2(1, "lyshark");
Student stu3(2, "admin");
if (stu1 == stu2)
cout << "stu1 = stu2" << endl;
if (stu1 != stu3)
cout << "stu1 != stu3" << endl;
system("pause");
return 0;
}本文作者： 王瑞
本文链接： https://www.lyshark.com/post/d874bf7f.html
版权声明： 本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
