C++笔记

最新推荐文章于 2024-01-08 13:00:40 发布

cj1064789374

最新推荐文章于 2024-01-08 13:00:40 发布

阅读量116

点赞数

分类专栏：剑指OFFER66题

本文链接：https://blog.csdn.net/cj1064789374/article/details/85020432

版权

剑指OFFER66题专栏收录该内容

13 篇文章 0 订阅

订阅专栏

重载：用同样的名字再定义一个不同参数的函数

命名：类名第一个字母大写，宏定义全大写，变量名除首单词每单词首字母大写

构造器：就是在构造对象时执行的代码
析构器：就是在销毁对象时执行的操

this指针：传入参数与成员属性同名时，用this->属性名表示属性……第一次区别JAVA的this.属性

基类继承子类：写法模板 class 子类 : public 基类名{…}

JAVA中默认子类构造器执行前不执行父类构造器，但是可以调用，而C++中是必须执行默认父类构造器的见如下代码
# include <bits/stdc++.h>
using namespace std;
class BaseClass
{
public:
BaseClass()
{
cout<<"Base begin without number"<<endl;
}
BaseClass(int c)
{
cout<<"Base begin with number"<<endl;
}
~BaseClass()
{
cout<<"Base end"<<endl;
}
Methon(int x)
{
cout<<"Base do"<<endl;
}
};

class SubClass:public BaseClass
{
public:
int real=0;
int imag=0;
SubClass()
{
cout<<"Sub begin without number"<<endl;
}
SubClass(int a,int b )
{
real=a;
imag=b;
cout<<"Sub begin with number"<<endl;
}
~SubClass()
{
cout<<"Sub end"<<endl;
}
Methon()
{
cout<<"Sub do"<<endl;
}
SubClass operator+(SubClass &d)
{
SubClass c;
c.real=real+d.real;
c.imag=imag+d.imag;
return c;
}
friend SubClass operator-(SubClass &d,SubClass &e);
friend std::ostream& operator<<(std::ostream& os,SubClass &e);
};
SubClass operator-(SubClass &d,SubClass &e)
{
SubClass c;
c.real=d.real-e.real;
c.imag=d.imag-e.imag;
return c;
}
std::ostream& operator<<(std::ostream& os,SubClass &e)
{
os<<'('<<e.real<<','<<e.imag<<')';
return os;
}
int main()
{
SubClass a(1,2);
SubClass b(5,6);
a.Methon();//b.Methon(3);
SubClass c(0,0);
cout<<c<<endl;cout<<c.real<<' '<<c.imag<<endl;
c=a+b;
cout<<c<<endl;cout<<c.real<<' '<<c.imag<<endl;
c=a-b;
cout<<c<<endl;cout<<c.real<<' '<<c.imag<<endl;
return 0;
}

继承时：用public是指原级别不变，用protected把原级别为public的改为protected，用private就是这个子类可以使用从父类继承的属性方法，但其子类就不行了

覆盖：子类中重写父类的方法，只要同名则已经叫做覆盖，子类对象就不可能调用父类方法（不同于重载不同参）……再次区分JAVA的子类可以重载父类方法

友元类：在某类A中加上friend class 类名B，这样A类可以访问及调用B类所有属性与方法

静态属性&静态方法
C++允许我们把一个或多个成员声明为属于某个类而不是仅属于该类的对象，这么做程序员可以在没创造任何对象可以调用方法与属性，有关数据在该类所有对象间共享
在属性与方法前加上static即可声明为静态，执行时直接是类名：：方法名或者类名：：属性名即可调用（不用创建对象）……类似JAVA
类对象在调用其方法时，此对象地址就传给了this指针
静态方法无法访问this指针，也无法该问非静态的类成员

虚方法：
声明指向父类类型的指针，但实际存储空间存的属性与方法是子类的，这里即使子类对父类的方法进行覆盖，也是调用父类的方法
克服上述问题，就是在父类的方法前加virtual，这样每次调用时，系统就会自动寻找指针真正子类覆盖的方法（父类一虚就会自动虚到底）……再次类似JAVA的abstract
例子如下（有NEW就有DELETE，用了指针就用->而不用.
int *pointer=new int;
*pointer=110;
cout<<*pointer;
delete pointer;

抽象方法：接口（对应），例如virtual void play()=0;直接就不用{}写这个函数的内容了。。。一句话，虚方法后面加=0就是抽象方法，基类中不写实现的方法

多态：一个名字定义不同函数，上面的重载是从编绎时的多态性，而运行时的多态性就是用virtual……三次区分JAVA是用super.来调用父类方法的毕竟人家是单继承，C++是规定的了
成员函数被重载特征：同一类中，函数名同，参数不同
覆盖是派生类函数覆盖基类函数其特征是：不同类，函数名同，参数同（我呸！），必须有virtual（我呸！）
虚方法一定要虚方法，这是为了当一个基类的指针删除一个派生类的对象时，派生类的析构函数可以被正确调用

运算符重载：
函数类型 operator 运算符名称（形参表列）
{
重载处理
}
有类成员函数与友元函数两种形式(见上面的例子)

多继承：有些问题可能得到了解释，在调用父类属性方法的时候，因为有了多继承好复杂，JAVA与C#都是没有的（说明其实用不上）
class 类名A：public 类名B，public 类名C
{
}

虚继承：子类属性里面可以继承两个不同的classes属性，的确是有两个不同的name属性
解决办法，两个父类都有name属性，那么就可以同时让两个父类虚继承自同一个爷类，这样爷类派生出的的name就只会有一个
class 类名A：virtual public 类名B
{
}

捕捉异常：try throw catch

动态内存：new了一个新指针，必须delete，然后置null
int *i=new int;//申请内存空间
delete i;//清空其指向地址值
i=NULL;//清空其地址值
int count=3;
int *x=new int[count];//相当于C的malloc

副本构造器：再写一个构造器，传入参数是同类另外一个对象，在指针赋值时要注意新建指针再赋值
……我终于明白为什么JAVA没有指针而只有声明了，而且还不用delete，其实无端为毛要有一个指针指向一个变量
//副本构造器类为point，属性只有一个int y
point(const point &other)
{
this->y=new int; //不需要假设对象已被创建并且初始化了，副本构造器当前的对象肯定是新建的
*(this->y)=*(other.y); //这里new 本对象y指向的内存是因为调用副本构造器的对象并没有调用构造器，如果写成this->y=other.y那就错了
}
//赋值操作函数，其实用不到的话可以不写，你直接用构造函数就好了，但若不在构造时，而是普通复制赋话还是要写的
point& point::operator=(const point &other){
if(this==&other) return *this;
delete y; //假设当前对象已经被提前创建出来并经过了初始化（y所指向的内存已被创建）
y=NULL;
y=new int;
*(this->y)=*(other.y); //假设y所指向的内存已被new
return *this;
}

头文件的使用（不同KELI需要设置h文件路径而不用添加H文件，不过所有C/CPP文件是一定要添加到工程中的）
新建工程main.cpp内容
#include<bits/stdc++.h>
#include "led.h"
using namespace std;
int main()
{
int i1=100,i2=200;
cout<<add(i1,i2)<<endl;
return 0;
}
同目录下新建led.cpp与led.h
//led.cpp
#include "led.h"
using namespace std;
int add(int a,int b)
{
return a+b;
}
//led.h
#ifndef LED
#define LED
int add(int a,int b);
#endif LED