本周学习总结

最新推荐文章于 2024-10-16 20:27:35 发布

达斯维达的大眼睛

最新推荐文章于 2024-10-16 20:27:35 发布

阅读量353

点赞数 5

文章标签：学习 c++ 笔记经验分享

本文链接：https://blog.csdn.net/EZ4Kerio/article/details/138751607

版权

一. C++

类和对象-继承
简单来说就是把父类的属性继承到子类
（1）基本语法

class 子类 ：继承方式 父类

（2）继承方式
继承方式分为三种，1公共继承，2保护继承，3私有继承，注意的是无论是哪种继承方式，都无法调用父类的private
A公共继承
简单来说就是把父类的public内容放到子类的public，父类的protected内容放到子类的protected，父类的private内容放到子类private，如以下列子

#include <iostream>
using namespace std;

class father
{
public:
	void fun1()
	{
		cout << "我是父类的public" << endl;
	}
protected:
	void fun2()
	{
		cout << "我是父类的protected" << endl;
	}
private:
	void fun3()
	{
		cout << "我是父类的private" << endl;
	}
};

class son : public father
{
public:
	void otherfun()
	{
		fun2();
		// fun3(); 无法调用，因为是父类似有的
	}
protected:

private:

};

int main()
{
	son s1;
	s1.fun1();
	s1.otherfun();
	return 0;
}

B私有继承
就是把父类的属性全部继承到子类的protected，如以下例子

#include <iostream>
using namespace std;

class father
{
public:
	void fun1()
	{
		cout << "我是父类的public" << endl;
	}
protected:
	void fun2()
	{
		cout << "我是父类的protected" << endl;
	}
private:
	void fun3()
	{
		cout << "我是父类的private" << endl;
	}
};

class son : protected father
{
public:
	void otherfun()
	{
		fun1();
		fun2();
		// fun3(); 无法调用，因为是父类似有的
	}
protected:

private:

};

int main()
{
	son s1;
	// 无法调用s1.fun1();，因为在protected里
	s1.otherfun();
	return 0;
}

C私有继承
即把父类的属性继承到子类的private里

#include <iostream>
using namespace std;

class father
{
public:
	void fun1()
	{
		cout << "我是父类的public" << endl;
	}
protected:
	void fun2()
	{
		cout << "我是父类的protected" << endl;
	}
private:
	void fun3()
	{
		cout << "我是父类的private" << endl;
	}
};

class son : private father
{
public:
	void otherfun()
	{
		fun1();
		fun2();
		// fun3(); 无法调用，因为是父类似有的
	}
protected:

private:

};

int main()
{
	son s1;
	// 无法调用s1.fun1();，因为在protected里
	s1.otherfun();
	return 0;
}

(3)构造和析构的顺序
因为父类和子类都是类，必然也少不了构造和析构函数，但处理顺序有点不同，这是我的一句话总结“先有爸爸后有儿子，白发人送黑发人”如以下列子

#include <iostream>
using namespace std;

class father
{
public:
	father()
	{
		cout << "这是父类的构造函数" << endl;
	}
	~father()
	{
		cout << "这是父类的析构函数" << endl;
	}
};

class son : public father
{
public:
	son()
	{
		cout << "这是子类的构造函数" << endl;
	}
	~son()
	{
		cout << "这是子类的析构函数" << endl;
	}
};

int main()
{
	son s1;
	
	return 0;
}

(4)同名函数和成员处理
如果父类和子类有相同的函数或成员，一般调用是调用子类，如要调用父类加作用域即可
如以下列子

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

class father
{
public:
	void fun()
	{
		cout << "我是父类的fun" << endl;
	}
	string s = "我是父类的string";
};

class son : public father
{
public:
	void fun()
	{
		cout << "我是子类的fun" << endl;
	}
	string s = "我是子类的string";
};

void test()
{
	son s1;
	//直接调用是子类
	s1.fun();
	cout << s1.s << endl;
	//调用父类需加作用域
	s1.father::fun();
	cout << s1.father::s << endl;
}
int main()
{
	test();
	return 0;
}

类和对象-多态
（1）满足条件和使用
条件
A：有继承关系
B：子类重写父类虚函数
使用：父类的指针或引用执行子类对象如以下列子

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

class father
{
public:
	virtual void fun()
	{
		cout << "我是父类的fun" << endl;
	}
	
};

class son : public father
{
public:
	void fun()
	{
		cout << "我是子类的fun" << endl;
	}
	
};

class bigson : public father
{
public:
	void fun()
	{
		cout << "我是bigson的fun" << endl;
	}

};

void whosefunisthis(father& a) //引用指向子类对象
{
	a.fun();
}


void test()
{
	son s1;
	bigson b1;
	whosefunisthis(s1);
	whosefunisthis(b1);
}
int main()
{
	test();
	return 0;
}

二. 数据结构

字符串暴力匹配
例如现有字符串ABABC，要匹配的字符串ABC

匹配顺序
以画图分析

主串和模式串：在字符串 a 中查找字符串 b，a 称为主串，b 称为模式串。
逐个比较：从主串的第一个字符开始，逐个与模式串的第一个字符进行比较。
匹配与不匹配：
如果当前字符匹配，继续比较下一个字符。
如果不匹配，主串的比较位置向右移动一位，模式串比较位置重置，然后重新开始比较。
代码实现

#include <stdio.h>
#include <stdlib.h>

typedef struct String 
{
     char* data;
     int len;
} String;

String* initString() 
{
    String* s = (String*)malloc(sizeof(String));
    s->data = NULL;
    s->len = 0;
    return s;
}

void stringAssign(String* s, char* data) 
{
    if (s->data) //先判断有没有数据，有则清空，避免野指针出现
    {
        free(s->data);
    }
    int len = 0;
    char* temp = data;
    while (*temp) //统计字符个数
    {
        len++;
        temp++;
    }
    if (len == 0) 
    {
        s->data = NULL;
        s->len = 0;
    }
    else 
    {
        temp = data;
        s->len = len;
        s->data = (char*)malloc(sizeof(char) * (len + 1)); //len+1是为了给\0
        for (int i = 0; i < len; i++, temp++) 
        {
            s->data[i] = *temp;
        }
    }
}

void forcematch(String* master, String* sub)
{
    int i = 0;
    int j = 0;
    while (i < master->len && j < sub->len)
    {
        if (master->data[i] == sub->data[j])
        {
            i++;
            j++;
        }
        else
        {
            i = i - j + 1; //开始回溯
            j = 0;
        }
    }
    if (j == sub->len)
    {
        printf("force match success\n");
    }
    else
    {
        printf("force match faile\n");
    }
}

void printString(String* s) {
    for (int i = 0; i < s->len; i++) 
    {
        printf(i == 0 ? "%c " : "-> %c ", s->data[i]);
    }
    printf("\n");
}

int main()
{
    String* s = initString();
    String* s1 = initString();
    stringAssign(s, "hello");
    stringAssign(s1, "he");
    printString(s);
    printString(s1);
    forcematch(s, s1);
    return 0;
}