一文带你从C快速过渡到C++

已于 2022-08-16 18:59:54 修改
阅读量4.9k 收藏 198
点赞数 56
文章标签： c++ c语言 开发语言 学习
于 2022-08-15 21:54:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dakhin/article/details/126355480
版权

P0 前言

很多同学都有这样的困扰，那就是已经学过C语言了，想学习C++，结果上网一搜发现，很多教程都是"C++重零开始到入门"之类的课，很多知识和C学习是重复，没必要浪费大量的时间重头开始学起。因此为了节约时间，有了以下笔记。本人仅仅是个小白，不是什么大神，只是愿意将自己的学习笔记分享出来而已，如有错漏，欢迎指正。

在这里插入图片描述

P1 C标准库—注释—条件编译

C++中包含了C标准库的移植版本，C标准库的头文件xx.h基本上变成了cxx

C库C++库
stdio.hcstdio
math.hcmath
string.hcstring
malloc.h(特别的)malloc.h

块注释：

/*...*/

单行注释：

//

条件编译

#if 0                  #if 1                          #ifdef XXX                    #ifndef XXX      

...                    ...                             ....                          ...

#endif                 #else                           #endif                        #else

​                       ...                                                            ...

					   #endif                                       		          #endif

例子：

#define _CRT_SECURE_NO_WARNINGS 
#include <cstdio> //标准输入输出函数 
#include <cmath> 
#include <cstring> //字符串处理函数 
int main() {
	printf("hello\n");
	double x = 3.14;
	printf("%lf %lf\n", sqrt(x), sin(x));

	char s[10] = "hello";
	puts(s);
	char s2[16];
	strcpy(s2, "world");
	puts(s2);
	strcat(s2, "sdfsdf");
	puts(s2);
	printf("%d %d\n", strlen(s), strlen(s2));
	return 0;
}

image-20220808153504265

P2 C++标准输入输出流—名字空间

  • 包含头文件#include
  • cout是一个标准输出流变量（对象），代表控制台窗口
  • <<是一个输出流运算符，o << x : 表示数据x输出到o
  • cout是标准名字空间std的一个名字，必须加上名字空间限定std::cout
    • std::cout << “Hello world” << endl;
    • using std::cout;
    • using namespace std
#include <iostream> //C++标准输入输出流头文件

using namespace std;

int main()
{
    cout << "hello world!" << endl;
    cout << "https://a.hwdong.com" << endl;
    cout << 3 + 4 << endl;


    double radius;
    cout << "Please enter r:\n";
    std::cin >> radius; //标准输入流对象cin 输入运算符>>

    cout << 3.14 * radius * radius << endl;

    std::cout << " *\n";
    std::cout << " * *\n";
    std::cout << " * *\n";
    return 0;
}

image-20220809103518257

#include <fstream> 
#include <iostream> 
#include <string> 
using namespace std;

int main() {
	ofstream oF("test.txt");
	oF << 3.14 << " " << "hello world\n";
	oF.close();
	ifstream iF("test.txt");
	double d;
	string str;
	iF >> d >> str;
	cout<<d <<" "<< str<<endl;

	return 0;
}

P3 引用变量、引用形参、默认形参

1.引用变量

  • 引用变量是其他变量的别名。如同一个人的外号或小名, 共用同一块内存

  • 定义引用变量时必须指明其引用的是哪个变量，且不能再指向其他变量

    int a = 3;
int &r = a;

2.引用形参

  • C语言中函数的形参以”值传递“的方式，形参的改变不会改变实参 void Fuction(int x, int y)
  • C语言中必须以指针的形式才能使形参改变时也改变形参void Fuction(int *x, int *y)
  • C++中可以使用”引用形参“实现指针传参的功能，本质都是地址
image-20220809204507305 
#include <iostream> 
using namespace std;

void swap(int &x, int &y) //X就是a，y就是b，没有产生新的内存块
{
	int t = x;
	x = y;
	y = t;
}

int main() 
{
	int a = 3, b = 4;
	cout << a << '\t' << b << endl;
	swap(a, b);
	cout << a << '\t' << b << endl;
}

image-20220809205430867

3.默认形参

  • 函数的默认形参必须在非默认形参右边，即一律靠右

  • 函数传参时，如果不赋值，按默认形参值执行

    void add(int x = 1, int y, int z = 3);   //错误
void add(int y, int x = 1, int z = 3);   //正确

    #include <iostream> 
using namespace std;

void print(char ch, int n = 1) {
	for (int i = 0; i < n; i++)
		cout << ch;
}

int main() {
	print('*'); cout << endl; //默认n=1,可以不写
	print('*',3); cout << endl;
	print('*',5); cout << endl;
}

    image-20220809210354657

P4 函数重载⭐

  • C++允许同一作用域里有同名的函数，只要它们的形参列表不同。如：

    int add(int x, int y);
int add(double x, double y);
double add(float x, float y);

  • 函数名+形参列表 构成了函数的签名，与返回类型无关,不能以返回类型区分函数。

    #include <iostream>

using namespace std;

int add(int x, int y)
{
    return x + y;
}

double add(double x, double y)
{
    return x + y;
}

int main()
{
    cout << add(5, 3) << endl;
    cout << add(5.3, 7.8) << endl;
    cout << add((double) 5, 7.8) << endl;
}

    image-20220809211443157

P5 函数模板

  • 泛化算法：用template关键字增加一个模板头，将数据类型变成类型模板参数

  • 函数模板不是函数，而是产生函数的模板，使用时，加上<类型>就会自动产生该类型的函数

  • 模板参数可以自动推断类型，为避免歧义，建议使用时还是加上<类型>

    template<typename T> //每一个函数模板都需要加这个
T add(T x, T y)
{
	return x + y;
}

    例子：

    #include <iostream>
#include <string>

using namespace std;

template<typename T>
T add(T x, T y)
{
    return x + y;
}

int main()
{
    cout << add(5, 3) << endl; //自动推断类型
    cout << add<double>(5, 7.8) << endl; //歧义性
    cout << add<string>("hello", " world") << endl;
}

    image-20220809214933906

P6 用户定义类型（string、vector）

1.string（字符串）

  • 是一个用户定义类型，表示符串

    string s = "hello", s2 = "world"

  • 可以用成员访问运算符 ” . “访问string类的成员

    int a=s.size() //取大小
s=s.substr(1,3) //取第1~3位的字符,返回字符串
int a=s.find("orl") //查找字符串，返回所在下标
s.insert(3,"ABCD") //在下标3前插入字符串
s.insert(3,4,'w') //在下标3前插入4个w
s1.swap(s2) //交换s1,s2的内容

s1.append(s2) //添加s2的内容到s1：s1="123",s2="abc",->s1="123abc"
s1.append(s2);  // s1 = "123abc"
s1.append(s2, 1, 2);  // s1 = "123bc"
s1.append(3, 'K');  // s1 = "123KKK"
s1.append("ABCDE", 2, 3);  // s1 = "123CDE"，添加 "ABCDE" 的子串(2, 3)

s=s.replace(2,3,"aa") //用aa替换原来字符串的第2-3位，返回字符串
s=to_string(a) //把数值类型转化为string
int a=stoi(s1) //把string转化为数值类型int
float a=stof(s1) //把string转化为数值类型flloat

s1.assign(s2) //用s2给s1赋值
s1.assign(s2,2,3) //用s2的第2~3位给s1赋值
s1.assign(10,'c') //用10个c给s1赋值

  • 可以用运算符” + “、” [] “(下标运算符)，处理string

    s + s2 //拼接两个字符串
s[0] = 'H' //访问s字符的第0个成员

    例子：

    #include <iostream>
#include <string>

using namespace std;

int main()
{
    string s = "hello", s2("world");
    //访问运算符.

    cout << s.size() << endl;
    string s3 = s.substr(1, 3);
    cout << s3 << endl;

    string s4 = s + " " + s2;
    cout << s4 << endl; //"hello world"


    s4[0] = 'H';
    s4[6] = 'W';
    cout << s4 << endl;

    int pos = s4.find("orl");
    cout << pos << endl;
    s4.insert(3, "ABCD");
    cout << s4 << endl;

    for (int i = 0; i < s4.size(); i++)
        cout << s4[i] << "-";
    cout << "\n";

    string s5 = "1234.5";
    float a = stof(s5);
    cout << a << endl;

}

    image-20220809224026835

2.vector（动态数组）

在C语言中，定义了一个静态数组后，其大小就固定了，不能再改变。

而在C++中，加入了vector的类，可以随时改变数组的大小。

  • 向量，类似于数组，但可以动态增长。头文件
  • 是一个类模板，实例化产生一个类，如vector产生一个int类型的vector类（向量）
  • 同样可以通过vector类对象去访问其成员，如成员访问函数
  • 同样可以用符号运算符进行一些运算
vector::push_back(x) //在容器最后一个位置插入元素x
vector::pop_back() //删除最后一个元素
vector::size() //返回元素个数
vector::capacity() //返回空间大小
vector::resize(n) //重新分配成员个数为n
vector::reserve(n) //重新分配空间大小为n
vector::clear() //清空容器内容，但空间没改变
vector::begin() //返回初始地址
vector::end() //返回结尾地址
    
vector::erase()//删除元素或⼀段序列
iterator erase(iterator position);
iterator erase(iterator first, iterator last);

vector::insert()//插⼊新的元素
iterator insert(iterator position, const T &x); //v.insert(v.begin()+1,3)在第1位前插入3
void insert(iterator position, size_type n, const T &x);
void insert(iterator position, InputIterator first, InputIterator last);
//第⼀个函数，在迭代器指定的位置前插⼊值为x的元素
//第⼆个函数，在迭代器指定的位置前插⼊n个值为x的元素
//第三个函数，在迭代器指定的位置前插⼊另外⼀个容器的⼀段序列迭代器first到last若插⼊新的元素后总得元素个数⼤于capacity，则重新分配空间

#include <iostream>
#include <vector>

using namespace std;

int main()
{
    vector<int> v = {7, 5, 16, 8};
    //push_back()，最后添加一个元素

    v.push_back(25);
    v.push_back(13);

    //成员函数size()、下标运算符[]
    for (int i = 0; i < v.size(); i++)
        cout << v[i] << '\t';
    cout << '\n';

    v.insert(v.begin()+1, 9); //插入不能用下标
    v.pop_back();

    for (int i = 0; i < v.size(); i++)
        cout << v[i] << '\t';
    cout << '\n';

    v.resize(2);

    for (int i = 0; i < v.size(); i++)
        cout << v[i] << '\t';
    cout << '\n';
}

image-20220810220019642

P7 指针和动态内存分配

1.指针

⭐约定：指针就是地址！变量的指针就是变量的地址。

  • 可以用取地址运算符&获得一个变量的地址，如&var

  • 指针变量就是存储指针（地址）的变量，如Type *P; //P是存储 ”Type类型变量的地址“ 的变量

  • 可以通过取内容运算符*得到一个指针变量指向的变量，如 *P就是P指向的那个变量

/* 指针就是地址，变量的指针就是变量的地址。 指针变量就是存储指针（地址）的变量。 */

#include <iostream> 
using namespace std;

int main() {
	int a=3;
	int *p = &a;   //取地址运算符&用于获得a的地址：&a
	cout << p << '\t' << &a << endl;     //p就是a的地址
  
	//取内容运算符*用于获得指针指向的变量(内存块)
	cout << *p << '\t' << a << endl;     //*p就是a
  
	*p = 5;                              //即a = 5;
	cout << *p << '\t' << a << endl;
 
	int *q = p;             //q和p值相同，都是a的地址(指针)
	cout << *p << '\t' << *q << '\t' << a << endl;
}

2.动态内存分配（new）

  • new 可以代替 molloc, 且会对对象进行初始化（在类中很有用）

​ int *p = new int; // p在函数的堆栈区，new在全局共享未使用堆存储区

  • delete可以代替free

    delete p; //释放p指向的内存，p本身没有被删掉

    delete[] p; //释放数组p指向的内存

/* malloc free realloc 动态内存分配：new用于申请内存块、delete用于释放内存块 T *p = new T; delete p; T *q = new T[5]; delete[] q; */
// 堆存储区
#include <iostream>
using namespace std;

int main()
{
    int *p = new int;
    *p = 3;
    cout << p << '\t' << *p << endl;
    delete p;   //内存泄漏，释放p指向内存

    p = new int; //p又指向一个新的内存
    *p = 5;
    cout << p << '\t' << *p << endl;
    delete p;
}

image-20220810223252462

P8 类和对象

1.面向对象编程

  • 传统的过程式编程：变量（对象）就是一些存储数据的内存块，而过程（函数）对这些数据进行处理。
image-20220811124633548

问题：数据不安全、维护困难（一个数据错误，很多函数都可能调用）

  • 面向对象编程：程序是由不同种类的许多对象相互协助完成的。对象之间通过发送/接收消息来协作完成各种任务。
image-20220811124915969 image-20220811150942421

2.对象特性：用户定义类型

  • 程序员定义自己的“用户定义类型”，如类类型，来表示各种应用问题中的各种概念

  • C++标准库提供了很多实用的标准“用户定义类型”

    1. cout是一个ostream类的对象（变量），cin是一个istream的对象（变量）

    2. string是一个表示字符串的类。向一个string对象发送一个size()消息，查询该对象包含的字符数目

      string str = "Hello world"; cout << str.size();

3.定义类(class)

  • 用struct或class关键字定义一个类。定义的类就是一个数据类型。

    struct student
{
	string name;
	double score;
}

  • class student{
private:
	string name;
	double score;
public: //接口
	void print() {cout << this->name << " " << this->score << endl;}
	string get_name() { return name; }
	double get_score() { return score; }
	void set_name(string n) { name = n; }
	void set_score(double s) { score = s; }
};

  • 类类型的变量通常称为对象。如：student stu；（对象就是类的一个实例）

  • 可以定义类类型的数组，存储一组类对象。如 student stus[3];

  • T是一个类类型，则T *就是T指针类型。 T *变量可以指向一个类对象。

    如 student *p = &stu; (p是一个student *指针变量，可以存放一个student类型的地址)

    image-20220811154253900
image-20220811154329818

  • 类体定义成员函数

    struct student{//体内
	string name;
	double score;
	void print(){cout << name << " " << score << endl;}; //函数声明
}

    struct student{//体外
	string name;
	double score;
	void print(); //函数声明
}
void student::print(){ //函数的实现
	cout << name << " " << score << endl;
}

    注意：C语言中struct不能定义函数成员，而C++中可以，不过为了区分建议用class，且class有封装特性，自行决定成员公开还是私有，struct默认所有成员公开！！！

4.学生成绩分析

/* 输入一组学生成绩(姓名和分数)，输出：平均成绩、最高分和最低分。 当然，也要能输出所有学生信息 */
#include <iostream>
#include <string>
#include <vector>
using namespace std;

struct student
{
    string name;
    double score;
    void print();
};

void student::print()
{
    cout << name << " " << score << endl;
}

int main()
{
    /* student stu; stu.name = "Li Ping"; stu.score = 78.5; stu.print(); */
    vector<student> students; //动态类数组

    while (1)
    {
        student stu;
        cout << "请输入姓名 分数:\n";
        cin >> stu.name >> stu.score;
        if (stu.score < 0) break;
        students.push_back(stu);
    }
    for (int i = 0; i < students.size(); i++)
        students[i].print();

    double min = 100, max = 0, average = 0;
    for (int i = 0; i < students.size(); i++)
    {
        if (students[i].score < min) min = students[i].score;
        if (students[i].score > max) max = students[i].score;
        average += students[i].score;
    }
    average /= students.size();
    cout << "平均分、最高分、最低分："
         << average << " " << max << " " << min << endl;
}
image-20220811160939076

P9 访问控制、基础函数⭐⭐

1.this指针

struct student{//体内
	string name;
	double score;
	void print(){cout << name << " " << score << endl;}; //函数声明
}

在类里面定义的成员函数，实际上编译器会自动转化为外部函数，并带this指针

struct student{
	string name;
	double score;
    //void print(){cout << name << " " << score << endl;}; //函数声明
}
void print(student *this){//函数声明
	cout << this->name << " " << this->score << endl;
}; 
int main(){
    student stu;
    stu.name = "LI";
    stu.score = 88;
    stu.print(); // print(&stu) 会转化为指针参数
}

2.访问控制（封装）

private:私有的，只能通过类体内访问

public:公开的，可以在类体外访问

protected：受保护的，只能在类体内访问或在体外通过成员函数访问

/* struct和class区别： struct里的成员默认是public(公开的) class里的成员默认是private(私有的) */
#include <iostream> 
#include <string> 
using namespace std;

class student{
public: //接口
	void print() {cout << this->name << " " << this->score << endl;}
	string get_name() { return name; }
	double get_score() { return score; }
	void set_name(string n) { name = n; }
	void set_score(double s) { score = s; }
private:
	string name;
	double score;
protected：
    string lover；
};

int main() {
	student stu;
	stu.set_name("Li Ping");
	stu.set_score(78.5);
	stu.print();   // print(&stu);
	cout << stu.get_name() << " " << stu.get_score() << endl;
}

3.构造函数

  • C++在创建一个类对象的时候，会自动调用被称为“构造函数”的成员函数

  • 如果没有定义构造函数，那么C++会自动生成一个构造函数：类名函数，且没有返回、没有形参，函数体里什么也不做

    class student
{
    string name;
    double score;
public:
    student(string n, double s)：name(n),score(s)//用列表初始化
    { 
        cout << "构造函数\n";
    }
}

/*等价于*/
    
class student
{
    string name;
    double score;
public:
    student(string n, double s)：
    { 
        name = n;
        score = s;
        cout << "构造函数\n";
    }
}

/* 构造函数： 函数名和类名相同且无返回类型的成员函数。 */
#include <iostream>
#include <string>
using namespace std;

class student
{
    string name;
    double score;
public:
    student(string n, double s)
    { //不是默认构造函数，重载
        name = n;
        score = s;
        cout << "构造函数\n";
    }
   
    student()
    {
        cout << "构造函数" << endl;
    }

    void print()
    {
        cout << this->name << " " << this->score << endl;
    }
};

int main()
{
    student stu("LiPing", 80.5); //在创建一个类对象时会自动调用称为“构造函数”的成员函数
    stu.print();
    student students[3];
}

image-20220812204708388

4.拷贝构造函数

  • 当我们定义一个类的新对象等于一个旧对象时，系统默认调用的是硬拷贝构造函数，即两个对象共用一个内存。

    class String{
	char *data;
	int n;
public:
	String(const String &s){//系统默认硬拷贝构造函数
		data = s.data;
		n = s.n;
	}
    String(const char *s = 0) //重载构造函数
    {
        if (s == 0)
        {
            data = 0;
            n = 0;
            return;
        }
        const char *p = s;
        while (*p) p++;
        n = p - s;
        data = new char[n + 1];
        for (int i = 0; i <= n; i++)
            data[i] = s[i];
    }
}

  • 但实际上我们希望定义的新对象拥有一块单独的内存，因此，需要重构 拷贝构造函数

class String{
	char *data;
	int n;
public:
	String(const String &s){//重载拷贝构造函数->软拷贝
		data = new char[s.n+1]; //开辟新内存
		n = s.n;
		for (int i = 0; i <= n; i++)
            data[i] = s.data[i];
	}
    String(const char *s = 0) //重载构造函数
    {
    }
}

例子：

#include <iostream>

using namespace std;

class String
{
    char *data; //C风格的字符串
    int n;

public:
    String(const String &s)
    {//重载拷贝构造函数
        data = new char[s.n + 1]; //申请新的内存
        n = s.n;
        for (int i = 0; i <= n; i++)
            data[i] = s.data[i];
    }

    String(const char *s = 0)
    {//重载构造函数
        if (s == 0)
        {
            data = 0;
            n = 0;
            return;
        }
        const char *p = s;
        while (*p) p++;
        n = p - s;
        data = new char[n + 1];
        for (int i = 0; i <= n; i++)
            data[i] = s[i];
    }

    int size()
    { return n; }

    char operator[](int i) const //const对象专用的下标重载
    {
        if (i < 0 || i >= n) throw "下标非法";
        return data[i];
    }

    char &operator[](int i)
    {
        if (i < 0 || i >= n) throw "下标非法";
        return data[i];
    }

    friend ostream &operator<<(ostream &o, String s);//这里也调用了拷贝构造函数
};

ostream &operator<<(ostream &o, String s)
{
    for (int i = 0; i < s.size(); i++)
        cout << s[i];
    return o;
}

int main()
{
    String str, str2("hello world");//注意str分配的内存是0，str不能直接使用
    cout << str2 << endl;
    str2[1] = 'E';
    cout << str2 << endl;
    String const str3 = str2; //重载了拷贝构造函数，str3是单独内存
    str2[0] = 'H';
    cout << "str2: " << str2 << endl;
    cout << "str3: " << str3 << endl;

    return 0;
}

image-20220813232515381

5.友元函数

外部函数想要调用类的成员时，可以在类中声明该函数为友元函数。

/*友元函数，允许外部函数访问类内部成员*/
class  student
{
	string name;
	double score;
public:
	student(string n, double s)
	{
		name = n; score = s;
	}
	friend ostream& operator<<(ostream &out, student s);//友元函数
}

ostream &operator<<(ostream &out, student s)
{
     cout << s.name << " "<< s.score << endl;
     return o;
}

6.析构函数

  • 很多时候构造函数内申请动态内存，如果不及时释放掉，可能会造成内存泄漏的灾难，因此要有析构函数释放不用的内存
  • 析构函数由 ~类名 构成，没有形参列表，也没有返回，后定义的先释放（堆栈类型）。
  • 析构函数一般要搭配拷贝构造函数使用，否则，系统默认拷贝会让两个对象共用一块内存，而析构函数会释放两次内存，造成错误
class String {
	char *data; //C风格的字符串
	int n;
public:
	~String() { //重载析构函数
		cout <<n<< " 析构函数!\n";
		if(data)
			delete[] data;
	}
	String(const String &s) { //重载拷贝构造函数
		cout << "拷贝构造函数!\n";	
		data = new char[s.n + 1];		
		n = s.n;		
		for (int i = 0; i < n; i++)
			data[i] = s.data[i];
		data[n] = '\0';
	}
	String(const char *s=0) { //构造函数
	}

7.const常函数

  • 基础，修饰变量

  • const int a=10;//a不可改

const int* a = &b://整型不可修改，但指针指向可以修改，*a不可改，a可改

int *const a = &b；//整型可修改，指针不可修改，*a可改，a不可改
 
const int *const p//二者都不可以改
    
void fun(const int i){}//i不能被修改

  • 进阶，const在类函数中的作用

    1.const修饰的函数，不能修改类中的成员变量，这是const修饰函数的基本作用

    2.未重载时，非const对象和const对象都能调用这个函数

    3.重载时， const对象调用const修饰的重载函数；非const对象调用非const函数

    class A
{
public:
  void f(int i){......} //一个函数
  void f(int i) const {......} //上一个函数的重载
};

    #include <iostream>
#include <string>
using namespace std;

class Test
{
public:
    Test();
    ~Test();
    int num;
    int fun(int b);
    int fun(int b) const;
    int gun(int b) const;
};

Test::Test()
{
    cout << "Test()" << endl;
}
Test::~Test()
{
}

int Test::fun(int b)
{
    cout << " int fun(int b);" << endl;
    num = 2;
    return 0;
}

int Test::fun(int b) const
{
    cout << " int fun(int b) const;" << endl;
    return 0;
}

int Test::gun(int b) const
{
    cout << " int gun(int b) const;" << endl;
    return 0;
}

int main()
{
    Test test;
    const Test testConst;

    test.fun(3); //非const变量调用非const函数
    testConst.fun(3); //const变量调用const函数
    test.gun(3); //非const变量也可以调用const函数

    return 0;
}

P10 运算符重载⭐

operator

1.流运算符重载

  • 结合P4 函数重载 学习

  • c++中允许对运算符进行重载，只要他们的形参列表不一样

ostream& operator << (ostream &out, student s)//重载输出流
{
    cout << s.name << " "<< s.score << endl;
	return out;//引用，返回自身&,不加返回的是一个复制值
}

istream& operator>>(istream &in, student &s) //重载输入流，注意是引用s
{
	in >> s.name >> s.score;
	return in;
}

2.下标运算符

  • 如果想在类中使用下标运算符，必须在成员里定义operator[]
class Point{
	double x, y;
public:	
	double operator[](int i) const{ //const函数
  
		if (i == 0) return x;
		else if (i == 1) return y;
		else throw "下标非法!"; //抛出异常
	}
	double& operator[](int i) {
		if (i == 0) return x;
		else if (i == 1) return y;
		else throw "下标非法!"; //抛出异常  
	}
    
	Point(double x_,double y_) {
		x = x_; y = y_;
	}

	//友元函数
	friend ostream & operator<<(ostream &o, Point p);
	friend istream & operator>>(istream &i, Point &p);
};

3.加法运算符

既可以定义在类体外，也可以定义在类体内，注意两种写法不同

//类体内
class student{
public:
	Point operator+(const Point q) {
		return Point(this->x + q[0], this->y + q[1]);
	}
}

//类体外
Point operator+(const Point p,const Point q) { return Point(p[0] + q[0], p[1] + q[1]);

例子：

#include <iostream> 
#include <string> 
using namespace std;

class Point{
	double x, y;
public:	
	double operator[](int i) const{ //const函数
  
		if (i == 0) return x;
		else if (i == 1) return y;
		else throw "下标非法!"; //抛出异常
	}
	double& operator[](int i) {
		if (i == 0) return x;
		else if (i == 1) return y;
		else throw "下标非法!"; //抛出异常
    
	}
    
	Point(double x_,double y_) {
		x = x_; y = y_;
	}
	Point operator+(const Point q) {
		return Point(this->x+q[0],this->y + q[1]);
	}

	//友元函数
	friend ostream & operator<<(ostream &o, Point p);
	friend istream & operator>>(istream &i, Point &p);
};

ostream & operator<<(ostream &o, Point p) {
	o <<p.x << " " << p.y<< endl;
	return o;
}
istream & operator>>(istream &i, Point &p) {
	i >> p.x >> p.y;
	return i;
}
/* Point operator+(const Point p,const Point q) { return Point(p[0] + q[0], p[1] + q[1]); } */

int main() {
	Point p(3.5, 4.8),q(2.0,3.0);	
  
// cin >> p;
	cout << p;
	cout << p[0] << "-" << p[1] << endl; //p.operator[](0)
  
	p[0] = 3.45; p[1] = 5.67;
	cout << "p: "<<p<<"q: "<<q;	
	Point s = p + q; //p.operator+(q) vs operator+(p,q)
	cout << s;
}

image-20220812224256428

P11 类模板

  • 类似于函数模板，类模板不是类，而是产生类的模板，可以让类代码复用

  • template<typename T> //创建类模板
class Vector {
	T *data;
	int capacity;
	int n;
public:
	Vector(int cap=3) {
		data = new T[cap];//开辟的是3倍类型空间
		if (data == 0) {
			cap = 0; n = 0;
			return;
		}
		capacity = cap;
		n = 0;
	}
	void push_back(T e) {
		if (n == capacity) {//空间已经满
			cout << "增加容量！\n";
			T *p = new T[2 * capacity];
			if (p) {
				for (int i = 0; i < n; i++)
					p[i] = data[i];
				delete[] data;
				data = p;
				capacity = 2*capacity;
			}
			else {
				return;
			}
		}
		data[n] = e;
		n++;
	}
	T operator[](int i) const{
		if (i < 0 || i >= n) throw "下标非法!";
		return data[i];		
	}	
	int size() {
		return n;
	}
};

int main() {	
	Vector<int> v; //可以定义任意类型变量
	v.push_back(3);
	v.push_back(4);
	v.push_back(5);
	v.push_back(6);
	v.push_back(7);
	for (int i = 0; i < v.size(); i++)
		cout << v[i] << '\t';
	cout << endl;
}

  • 也可以使用系统自带的vector生成模板

    #include <iostream>
#include <string>
#include <vector>

using namespace std;

class student
{
    string name;
    float score;
public:
    student(string n = "no", float s = 0)
    {
        name = n;
        score = s;
    }

    friend ostream &operator<<(ostream &o, student s);
};

ostream &operator<<(ostream &o, student s)
{
    cout << s.name << "," << s.score << endl;
    return o;
}


int main()
{
    vector<student> v;//生成student类型的对象（向量形式、可自由生长）
    v.push_back(student("li", 60));
    v.push_back(student("wang", 70));
    v.push_back(student("zhao", 80));
    v.push_back(student("cen", 90));

    for (int i = 0; i < v.size(); i++)
        cout << v[i];
    cout << endl;

    return 0;
}

    image-20220814154941638

P12 类的继承

1.C++ 继承

面向对象程序设计中最重要的一个概念是继承。继承允许我们依据另一个类来定义一个类，这使得创建和维护一个应用程序变得更容易。这样做，也达到了重用代码功能和提高执行效率的效果。

当创建一个类时，您不需要重新编写新的数据成员和成员函数，只需指定新建的类继承了一个已有的类的成员即可。

这个已有的类称为基类，新建的类称为派生类。

继承代表了 is a 关系。例如，哺乳动物是动物，狗是哺乳动物，因此，狗是动物，等等。

img

当一个类派生自基类，该基类可以被继承为 public、protected 或 private 几种类型。继承类型是通过上面讲解的访问修饰符 access-specifier 来指定的。

我们几乎不使用 protected 或 private 继承，通常使用 public 继承。当使用不同类型的继承时，遵循以下几个规则：

  • 公有继承（public）：当一个类派生自公有基类时，基类的公有成员也是派生类的公有成员，基类的保护成员也是派生类的保护成员，基类的私有成员不能直接被派生类访问，但是可以通过调用基类的公有和保护成员来访问。

  • 保护继承（protected）： 当一个类派生自保护基类时，基类的公有和保护成员将成为派生类的保护成员。

  • 私有继承（private）：当一个类派生自私有基类时，基类的公有和保护成员将成为派生类的私有成员。

    访问publicprotectedprivate
    同一个类yesyesyes
    派生类yesyesno
    外部的类yesnono

    一个派生类继承了所有的基类方法，但下列情况除外：

    • 基类的构造函数、析构函数和拷贝构造函数。
    • 基类的重载运算符。
    • 基类的友元函数。

2.单继承

class <派生类名>:<继承方式1><基类名1>
{
	<派生类类体>
};

例子：

#include <iostream>
 
using namespace std;
 
// 基类
class Shape 
{
   public:
      void setWidth(int w)
      {
         width = w;
      }
      void setHeight(int h)
      {
         height = h;
      }
   protected:
      int width;
      int height;
};
 
// 派生类
class Rectangle: public Shape
{
   public:
      int getArea()
      { 
         return (width * height); 
      }
};
 
int main(void)
{
   Rectangle Rect;
 
   Rect.setWidth(5);//通过成员函数访问受保护变量
   Rect.setHeight(7);
 
   // 输出对象的面积
   cout << "Total area: " << Rect.getArea() << endl;

   return 0;
}

结果：Total area: 35

3.多继承

多继承即一个子类可以有多个父类，它继承了多个父类的特性。

C++ 类可以从多个类继承成员，语法如下：

class <派生类名>:<继承方式1><基类名1>,<继承方式2><基类名2>,…
{
<派生类类体>
};

其中，访问修饰符继承方式是 public、protected 或 private 其中的一个，用来修饰每个基类，各个基类之间用逗号分隔，如上所示。现在让我们一起看看下面的实例：

#include <iostream>
 
using namespace std;
 
// 基类 Shape
class Shape 
{
   public:
      void setWidth(int w)
      {
         width = w;
      }
      void setHeight(int h)
      {
         height = h;
      }
   protected:
      int width;
      int height;
};
 
// 基类 PaintCost
class PaintCost 
{
   public:
      int getCost(int area)
      {
         return area * 70;
      }
};
 
// 派生类
class Rectangle: public Shape, public PaintCost
{
   public:
      int getArea()
      { 
         return (width * height); 
      }
};
 
int main(void)
{
   Rectangle Rect;
   int area;
 
   Rect.setWidth(5);
   Rect.setHeight(7);
 
   area = Rect.getArea();
   
   // 输出对象的面积
   cout << "Total area: " << Rect.getArea() << endl;
 
   // 输出总花费
   cout << "Total paint cost: $" << Rect.getCost(area) << endl;
 
   return 0;
}

结果：

Total area: 35
Total paint cost: $2450

P13 类的多态

  • 如果说，继承是子类使用父类的代码，那么多态就是父类使用子类的代码。

1.虚函数

虚函数 是在基类中使用关键字 virtual 声明的函数。在派生类中重新定义基类中定义的虚函数时，会告诉编译器不要静态链接到该函数。

我们想要的是在程序中任意点可以根据所调用的对象类型来选择调用的函数，这种操作被称为动态链接，或后期绑定。

class Shape {
   protected:
      int width, height;
   public:
      Shape( int a=0, int b=0)
      {
         width = a;
         height = b;
      }
      virtual int area()//虚函数
      {
         cout << "Parent class area :" <<endl;
         return 0;
      }
};

2.纯虚函数

您可能想要在基类中定义虚函数，以便在派生类中重新定义该函数更好地适用于对象，但是您在基类中又不能对虚函数给出有意义的实现，这个时候就会用到纯虚函数。

我们可以把基类中的虚函数 area() 改写如下：

class Shape {
   protected:
      int width, height;
   public:
      Shape( int a=0, int b=0)
      {
         width = a;
         height = b;
      }
      // pure virtual function
      virtual int area() = 0;
};

= 0 告诉编译器，函数没有主体，上面的虚函数是纯虚函数。

3.多态

多态按字面的意思就是多种形态。当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。

C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。

例子：

#include <iostream> 
using namespace std;
 
class Shape {
   protected://受保护的，继承的类，只有在成员函数中才能访问
      int width, height;
   public:
      Shape( int a=0, int b=0)
      {
         width = a;
         height = b;
      }
      virtual int area() //虚函数，父类指针访问链接之类的接口
      {
         cout << "Parent class area :" <<endl;
         return 0;
      }
};
class Rectangle: public Shape{//继承父类
   public:
      Rectangle( int a=0, int b=0):Shape(a, b) { }//使用父类的构造函数
      int area () //重载父类成员函数，注意此时父类是虚函数，后面父类对象指针可调用该函数
      { 
         cout << "Rectangle class area :" << width * height << endl;
         return (width * height); 
      }
};
class Triangle: public Shape{
   public:
      Triangle( int a=0, int b=0):Shape(a, b) { }
      int area ()
      { 
         cout << "Triangle class area :" << width * height / 2 << endl;
         return (width * height / 2); 
      }
};
// 程序的主函数
int main( )
{
   Shape *shape;
   Rectangle rec(10,7);
   Triangle  tri(10,5);
 
   // 存储矩形的地址
   shape = &rec;
   // 调用矩形的求面积函数 area
   shape->area();
 
   // 存储三角形的地址
   shape = &tri;
   // 调用三角形的求面积函数 area
   shape->area();
   
   return 0;
}

image-20220815213132913

后记

本文主要参考了：
hw-dong老师的博客：https://hwdong.net/
菜鸟C++教程：https://m.runoob.com/cplusplus/
cppreference: https://zh.cppreference.com/w/cpp

谢谢，如果对你有帮助，记得点个赞噢

Dakhin
关注
  • 56
    点赞
  • 踩
  • 198
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
一文带你读懂Mysql和InnoDB存储引擎
02-24
作为一名开发人员，在日常的工作中会难以避免地接触到数据库，无论是基于文件的sqlite还是工程上使用非常广泛的MySQL、PostgreSQL，但是一直以来也没有对数据库有一个非常清晰并且成体系的认知，所以最近两个月的时间看了几本数据库相关的书籍并且阅读了MySQL的官方文档，希望对各位了解数据库的、不了解数据库的有所帮助。本文中对于数据库的介绍以及研究都是在MySQL上进行的，如果涉及到了其他数据库的内容或者实现会在文中单独指出。数据库的定义很多开发者在最开始时其实都对数据库有一个比较模糊的认识，觉得数据库就是一堆数据的集合，但是实际却比这复杂的多，数据库领域中有两个词非常容易混淆，也就是数
一文带你了解HTTP黑科技
02-24
什么是内容协商在HTTP中，内容协商是一种用于在同一URL上提供资源的不同表示形式的机制。内容协商机制是指客户端和服务器端就响应的资源内容进行交涉，然后提供给客户端最为适合的资源。内容协商会以响应资源的语言、字符集、编码方式等作为判断的标准。内容协商主要有以下3种类型：服务器驱动协商（Server-drivenNegotiation）这种协商方式是由服务器端进行内容协商。服务器端会根据请求首部字段进行自动处理客户端驱动协商（Agent-drivenNegotiation）这种协商方式是由客户端来进行内容协商。透明协商（TransparentNegotiation）是服务器驱动和客户端驱动的结合
高效C++：从C到C++
07-07
高效C++：从C到C++word文档
一文带你看清HTTP所有概念
02-24
先来回顾一下HTTP1.1标头都有哪几种HTTP1.1的标头主要分为四种，通用标头、实体标头、请求标头、响应标头，现在我们来对这几种标头进行介绍HTTP通用标头之所以这样命名，是因为与其他三个类别不同，它们不是限定于特定种类的消息或者消息组件（请求，响应或消息实体）的。HTTP通用标头主要用于传达有关消息本身的信息，而不是它所携带的内容。它们提供一般信息并控制如何处理和处理消息。尽管通用标头不会限定于是请求还是响应报文，但是某些通用标头大部分或全部用于一种特定类型的请求中。也就是说，如果某个通用标头出现在请求报文中，那么大部分通用标头都会显示在该请求报文中。响应报文也是一样的。先列出来一个清单
从C语言过渡到C++之引用（别名）
08-29
本文给大家讲解的是在从C语言过渡到C++中的引用的区别及简单示例，有需要的小伙伴可以参考下
超详细C转C++简单教程(算法竞赛所需)
热门推荐
wfuzhuandaaliu的博客
01-18 1万+
说实话，用c语言来写算法竞赛(蓝桥杯，acm)也是完全没有问题的，说是转型c++，其实并不是，只是借助了c++的一些STL容器(听起来很高级，其实就是栈，队列啥的)和一些库函数，例如sort函数，比快速排序啥的都要快，c++只需要一行就搞定了，不用再像c语言一样写很多，并不是真正的转型，也没必要担心自己学不会，还是c语言那老一套，只不过scanf printf换成cin cout等等。不过，用c++来写，确实省时省劲，还是很值得去学的！ 有很多教程和视频都做得十分晦涩难懂，生怕你学会了…所以我今天来做个简单
从C语言快速过渡到C++
CMtotoe的博客
01-22 3157
帮助学会C语言的同学快速过渡到C++
C++ | 手把手带你从C语言到C++
Nice_W的博客
02-10 2884
命名空间的定义有关键字+命名空间名+{}组成，具体定义如下；//声明或定义（命名空间成员）int a;char c;以上代码定义了一个名叫zhangsan的命名空间，该命令空间有三个成员，分别声明了一个整型a，一个字符型c和一个函数Swap；注意：命名空间不可定义在函数和类的内部int main()int a = 0;int& ra1；// err 未初始化// 正确return 0;
深入浅出C++（一）：C到C++的升级
Exp.Joker
04-07 491
一、学习C++的意义 1、C语言的特点 2、软件方法论的发展 3、C语言的加强 4、学习C++的优势 5、现代软件产品架构图 6、现代软件产品的特性 7、学习C++的意义 8、小结 二、C到C++的升级 1、C与C++的关系 实例分析：C到C++的升级一 实例分析：C到C++的升级二 2、小结
一、从C到C++
Gelercat的博客
10-04 712
一些从C到C++快速入门
一文带你了解半导体硅晶片
01-20
硅片是生产集成电路的主要原材料。硅片尺寸越大则每片硅片上可以制造的芯片数量就越多，从而制造成本就越低。硅片尺寸的扩大和芯片线宽的减小是集成电路行业技术进步的两条主线。目前12寸硅片的出货量占比超过60％，是目前主流的硅片尺寸。 　　半导体硅片通常由高纯度的多晶硅锭釆用查克洛斯法（CZ Method）为主拉成不同电阻率的硅单晶锭，然而经过晶体定向→外圆滚磨→加工主、副参考面→切片→倒角→热处理→研磨→化学腐蚀→抛光→清洗→检测→包装等工序。 　　根据硅纯度的不同要求，可分为太阳能等级99，9999％，6个“9”纯度，以及半导体等级11个“9”。本文只涉及半导体用的硅片。
记录学习完C语言后，学习C++的过程，实现从C语言到C++的过渡.zip
最新发布
06-25
c 代码
Istio是啥？一文带你彻底了解！
02-24
官方对Istio的介绍浓缩成了一句话：Anopenplatformtoconnect,secure,controlandobserveservices.翻译过来，就是”连接、安全加固、控制和观察服务的开放平台“。开放平台就是指它本身是开源的，服务对应的是微服务，也可以粗略地理解为单个应用。中间的四个动词就是Istio的主要功能，官方也各有一句话的说明。这里再阐释一下：连接（Connect）：智能控制服务之间的调用流量，能够实现灰度升级、AB测试和红黑部署等功能安全加固（Secure）：自动为服务之间的调用提供认证、授权和加密。控制（Control）：应用用户定义的policy，保证资源在消费者
一文教你从0到1了解模拟电路设计
01-20
数字信号处理算法和集成电路迅猛发展，虽然许多类型的信号处理已经由模拟电路转换成数字电路来实现，但是在一块芯片中，模拟电路是必不可少的。作为一个模拟电路设计师中的菜鸟，说一下自己学习和工作中的一些心得体会。 　　我从研究生开始接触模拟集成电路到现在有四年了，有读过“模拟芯片设计的四重境界”这篇文章，我现在应该处于菜鸟的境界。 　　 　　模拟电路设计和数字电路设计是有很大区别的，基本的是模拟电路处理的是模拟信号，数字电路处理的数字信号。模拟信号在时间和值上是连续的，数字信号在时间和值上是离散的，基于这个特点，模拟电路设计在某些程度上比数字电路设计困难。模拟电路设计困难的具体原因
一文带你读懂计算机视觉
01-27
最近，我已经阅读了很多与计算机视觉相关的资料并做了大量实验，这里介绍了在该领域学习和使用过程中有意思的内容。近年来，计算机视觉取得了很大进展。这些是我将在这里提到的主题：技术：人脸检测：Haar，HOG，MTCNN，Mobilenet人脸识别：CNN，Facenet目标识别：alexnet，inceptionnet，resnet迁移学习：在一个新场景上用很少的资源重新训练大型神经网络图像分割：rcnn生成式对抗网络计算机视觉所需硬件：选择什么，关键是GPU集成视觉的UI应用程序：ownphotos应用：个人图片整理自动驾驶汽车自动无人机验证码识别/OCR过滤网站/应用程序上的图片自动标记应
一文带你了解云原生
02-23
自进入云计算时代后，大量的新概念、新技术如雨后春笋般的涌现出来，从早期的openstack、IAAS平台，到中期的容器技术、微服务架构，再到现在的servicemesh服务网格技术、serverless无服务器架构、云原生技术，可谓在...
从C到C++
南风fahaxiki
03-04 836
一，从C语言到c++ 1，C语言基础语法 位运算 基础数据类型 三大控制结构 数组 函数 指针 结构体 文件操作 动态内存分配 malloc free 数据结构—链表 数据结构---栈 数据结构—队列 学完C语言只是会了基础，还要学习c++ c++ 位运算 基础数据类型 三大控制结构 数组 函数 指针 结构体 文件操作 动态内存分配 malloc free 数据结构—链表 数据结构---栈 数据结构—队列 C语言和C++的关系 C++...
从C语言到C++的进阶之C到C++的转变（篇一）
Viewinfinitely的博客
12-28 1248
C++是在C语言的基础上发展出来的，在C语言的基础上又形成了新的对象、类、继承等用法，本文专注于从C语言到C++的转变与进阶，不断深入学习C++语言程序设计。
OOP 面向对象编程：由 C语言到 C++
C语言与CPP编程的博客
12-19 996
链接：https://www.cnblogs.com/whale90830/p/10488595.html由C到C++OOP第一课C语言的局限C++的特点C++的程序特征C++程序的结构...
从初中高以次划分学习C语言需要掌握哪些知识
03-11
学习 C 语言需要掌握基本的计算机知识，包括数据类型、变量、运算符、控制语句、函数、指针等。此外，还需要了解一些基本的算法和数据结构，如数组、链表、栈、队列等。对于初学者来说，还需要掌握一些基本的编程思想和方法，如模块化、面向对象等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值