3小时OOP初探（C++）

最新推荐文章于 2023-10-27 22:37:31 发布
最新推荐文章于 2023-10-27 22:37:31 发布
阅读量364 收藏 2
点赞数 1
文章标签： cpp oop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zjugeek/article/details/54862324
版权

基于《Thinking in C++》

CPP复习笔记

1. 静态成员变量

  1. 静态成员变量用static修饰，它只属于类而不是对象，因此所有这个类的对象享用同一个静态变量值。

  2. 静态成员变量必须要在类外初始化 

    type class::name = value;

    初始化的时候不用带static但需要有类型，protected，privated，public都可以被这样初始化

  3. 静态成员变量的调用

    //通过类类访问 static 成员变量
Student::m_total = 10;
//通过对象来访问 static 成员变量
Student stu("小明", 15, 92.5f);
stu.m_total = 20;
//通过对象指针来访问 static 成员变量
Student *pstu = new Student("李华", 16, 96);
pstu -> m_total = 20;
  4. static 成员变量不占用对象的内存，而是在所有对象之外开辟内存，即使不创建对象也可以访问。
  5. 一个类中可以有一个或多个静态成员变量，所有的对象都共享这些静态成员变量，都可以引用它。
  6. static 成员变量和普通 static 变量一样，都在内存分区中的全局数据区分配内存，到程序结束时才释放。这就意味着，static 成员变量不随对象的创建而分配内存，也不随对象的销毁而释放内存。而普通成员变量在对象创建时分配内存，在对象销毁时释放内存。
  7. 静态成员变量初始化时可以赋初值，也可以不赋值。如果不赋值，那么会被默认初始化为 0。全局数据区的变量都有默认的初始值 0，而动态数据区（堆区、栈区）变量的默认值是不确定的，一般认为是垃圾值。
  8. 静态成员变量既可以通过对象名访问，也可以通过类名访问，但要遵循 private、protected 和 public 关键字的访问权限限制。当通过对象名访问时，对于不同的对象，访问的是同一份内存。
  9. 静态成员变量可以成为派生类和基类共同使用的数值，也可以成为成员函数的可选参数。
  10. 静态成员变量可以是所属类的类型，普通数据成员只能成为该类的指针或引用。

2. 静态成员函数

  1. 静态成员函数的地址可以用普通函数指针调用

    class A{
public:
        static fun(){};
        int fun1(){};
}

int (*pf1)()=&base::fun;
int (base::*pf2)()=&case::fun1;
  2. 静态成员函数不可以调用类的非静态成员，因为这个静态成员函数并不带有this指针。
  3. 静态成员函数不可以同时声明为 virtual const volatile函数。
  4. 静态成员函数不需要对象名即可调用。
  5. 非静态成员函数可以自由调用静态成员函数和静态成员变量。

3. 引用和地址

  1. 引用类似于某个变量的别名，完全享用同一片地址。
  2. 引用必须在定义的时候初始化。
  3. 引用对象已经初始化不能重新引用另外的变量。

4. 拷贝构造函数

  1. CExample(const CExample& C)　
    就是我们自定义的拷贝构造函数。可见，拷贝构造函数是一种特殊的构造函数，函数的名称必须和类名称一致，它必须的一个参数是本类型的一个引用变量。

  2. 调用时机

    • 类作为一个参数整体传入一个函数的时候，需要调用这个类的拷贝构造函数，进行形参和实参的复制
    • 类作为一个结果返回的时候，先产生一个临时变量，调用拷贝构造函数将返回值拷贝到临时变量，析构返回的变量，再析构临时变量

    • 需要通过另一个变量初始化的时候

      class mode{...}

mode A(10);
mode B = A;
  3. 拷贝构造函数分为浅拷贝和深拷贝。

  4. 默认拷贝构造函数是浅拷贝的一种

    • 默认拷贝构造函数无法处理静态成员变量只是简单复制
    • 需要自己写浅拷贝构造函数进行静态成员变量的复制
    • 如果被拷贝对象中包含指针，进行逐位拷贝后新旧两个指针将指向同一个空间，并且将被重复释放

  5. 深拷贝用于需要动态创建新空间时

    Rect(const Rect& r)  
{  
    width = r.width;  
    height = r.height;  
    p = new int;    // 为新对象重新动态分配空间  
    *p = *(r.p);  
}
    1. 可以创建一个private的拷贝构造函数声明来解决默认值拷贝。？？？

5. const

  1. 修饰指针变量时：
    • 只有一个const，如果const位于*左侧，表示指针所指数据是常量，不能通过解引用修改该数据；指针本身是变量，可以指向其他的内存单元。
    • 只有一个const，如果const位于*右侧，表示指针本身是常量，不能指向其他内存地址；指针所指的数据可以通过解引用修改。
    • 两个const，*左右各一个，表示指针和指针所指数据都不能修改。
  2. 修饰函数参数时:
    • 不能改变该参数的值。
  3. 修饰函数时：
    • 该函数不能改变调用的参数值，同样地，该函数也不能调用任何非const函数。
  4. 修饰返回值时：
    • 指针返回时：只能赋值给同样用const修饰的左值
    • 值传递时：const并没有什么意义

6. 对象初始化和析构

  1. 空初始化：即无参数无括号形式

    • 如int i，new int,new int[10].当在所有函数之外时，初始化为0；当在某一函数中时，没初始化。

  2. 值初始化：即无参数有括号形式，且括号只能在类型名后，而不能在变量名之后，即只能创无名对象，对象被值初始化为0.

    • 如：int() //创建了一个无名对象，其被值初始化为0.一般将该无名对象初始化化或赋值给某有名对象，或直接作为无名对象使用

  3. 显式初始化：即有参数有括号形式，且当为有名对象时括号在对象名之后，为无名对象时括号在类类型名之后。

    • 如：int i（5）；
      • new int(5);
  4. 以下四种必须使用初始化列表：
    • 初始化一个引用成员变量
    • 初始化一个const变量
    • 当我们在初始化一个子类对象的时候，而这个子类对象的父类有一个显示的带有参数的构造函数
    • 当调用一个类类型成员的构造函数，而它拥有一组参数的时候
  5. 析构函数通常使用默认析构函数，但是在之前进行空间改变（指针移位等）的时候一定要自己写析构函数。

  6. 析构数组或类组：

    class A
{
        A(){m_a=new int[10];}
        ~A(){delete [] m_a;}
        int * m_a;
}

  7. 强制类型转换支持但并不推荐，推荐使用以下较温和的方法：

    pd = static_cast<double*>(pv);
  8. 初始化列表不管怎么写，初始化的顺序也只是按照原类内声明的顺序进行。

7. 重载函数和默认参数

  1. 重载函数的调用匹配
    • 精确匹配：参数匹配而不做转换，或者只是做微不足道的转换，如数组名到指针、函数名到指向函数的指针、T到const T；
    • 提升匹配：即整数提升（如bool 到 int、char到int、short 到int），float到double
    • 使用标准转换匹配：如int 到double、double到int、double到long double、Derived*到Base*、T*到void*、int到unsigned int；
    • 使用用户自定义匹配；
    • 使用省略号匹配：类似printf中省略号参数
  2. 同一作用域中有相同函数名但是有不同参数列表的可见函数构成重载关系。
  3. 内层作用域的函数会隐藏外层的同名函数，同样的派生类的成员函数会隐藏基类的同名函数。
  4. 如果要在函数内部调用重名的全局变量则要以“:: va”这样的形式调用。
  5. 在编译器中，编译器看到的函数名为“类型+名称+从左往右的参数列表”，但事实上在调用重载函数时，仅仅有返回类型不同是不能成立的，因为编译器无法判断你调用的是哪个函数，具有二义性。

8. 运算符重载

  1. 两种重载方式的比较：

    • 一般情况下，单目运算符最好重载为类的成员函数；双目运算符则最好重载为类的友元函数。
      以下一些双目运算符不能重载为类的友元函数：=、()、[]、->。

    • 类型转换函数只能定义为一个类的成员函数而不能定义为类的友元函数。 C++提供4个类型转换函数：reinterpret_cast（在编译期间实现转换）、const_cast（在编译期间实现转换）、stactic_cast（在编译期间实现转换）、dynamic_cast（在运行期间实现转换，并可以返回转换成功与否的标志）。

    • 若一个运算符的操作需要修改对象的状态，选择重载为成员函数较好。

    • 若运算符所需的操作数（尤其是第一个操作数）希望有隐式类型转换，则只能选用友元函数。
      当运算符函数是一个成员函数时，最左边的操作数（或者只有最左边的操作数）必须是运算符类的一个类对象（或者是对该类对象的引用）。如果左边的操作数必须是一个不同类的对象，或者是一个内部 类型的对象，该运算符函数必须作为一个友元函数来实现。

    • 当需要重载运算符具有可交换性时，选择重载为友元函数。

  2. 注意事项：

    • 除了类属关系运算符”.“、成员指针运算符”.*“、作用域运算符”::“、sizeof运算符和三目运算符”?:“以外，C++中的所有运算符都可以重载。

    • 重载运算符限制在C++语言中已有的运算符范围内的允许重载的运算符之中，不能创建新的运算符。
      运算符重载实质上是函数重载，因此编译程序对运算符重载的选择，遵循函数重载的选择原则。

    • 重载之后的运算符不能改变运算符的优先级和结合性，也不能改变运算符操作数的个数及语法结构。

    • 运算符重载不能改变该运算符用于内部类型对象的含义。它只能和用户自定义类型的对象一起使用，或者用于用户自定义类型的对象和内部类型的对象混合使用时。

    • 运算符重载是针对新类型数据的实际需要对原有运算符进行的适当的改造，重载的功能应当与原有功能相类似，避免没有目的地使用重载运算符。

9. 继承和组合

  1. kind of关系下用继承，part of关系下用组合。

  2. 继承

    class Human
{
    …
};
class Man : public Human
{
    …
};
class Boy : public Man
{
    …
};

  3. 组合

    class Eye
{
    public:
            void Look(void);
};
class Nose
{
    public:
        　 void Smell(void);
};
class Mouth
{
    public:
        　void Eat(void);
};
class Ear
{
    public：
        　void Listen(void);
};

class Head
{
    public:
    　　void Look(void) { m_eye.Look(); }
    　　void Smell(void) { m_nose.Smell(); }
    　　void Eat(void) { m_mouth.Eat(); }
    　　void Listen(void) { m_ear.Listen(); }
    private:
    　　Eye m_eye;
    　　Nose m_nose;
    　　Mouth m_mouth;
    　　Ear m_ear;
};
  4. 继承的关系不同对这个派生类并无影响，而是对该派生类的派生类产生影响。例如private Base（10），则对于该派生类的派生类来说，Base不可见。

10. inline & extern

  1. 关键字inline 必须与函数定义体放在一起才能使函数成为内联，仅将inline 放在函数声明前面不起任何作用。
  2. 定义在类声明之中的成员函数将自动地成为内联函数。
  3. 宏替换是单纯地代码替换，inline函数真正具有函数的特征。
  4. extern 表示该声明已经定义在别的文件中了。

11. virtual函数与纯虚函数

  1. 虚函数：类Base中加了Virtual关键字的函数就是虚拟函数（例如函数print），于是在Base的派生类Derived中就可以通过重写虚拟函数来实现对基类虚拟函数的覆盖。当基类Base的指针point指向派生类Derived的对象时，对point的print函数的调用实际上是调用了Derived的print函数而不是Base的print函数。
  2. 我们只需在把基类的成员函数设为virtual，其派生类的相应的函数也会自动变为虚函数。也就是说，virtual函数被继承后可以自动动态绑定当前对象。

  3. 纯虚函数：只声明，无定义，包含纯虚函数的类称为抽象类，无实际作用，只作为基类。

    class <类名>
{
virtual <类型><函数名>(<参数表>)=0;
…
};

  4. 重载和覆盖的区别

    • 重载的几个函数必须在同一个类中；
      覆盖的函数必须在有继承关系的不同的类中
    • 覆盖的几个函数必须函数名、参数、返回值都相同；
      重载的函数必须函数名相同，参数不同。
    • 覆盖的函数前必须加关键字Virtual；
      重载和Virtual没有任何瓜葛，加不加都不影响重载的运作。

  5. 关于C++的隐藏规则：

    • 如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual
      关键字，基类的函数将被隐藏（注意别与重载混淆）。
    • 如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual
      关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）。

  6. 重写 重载 重定义

    • 重写(override):
      父类与子类之间的多态性。子类重新定义父类中有相同名称和参数的虚函数。

      • 1) 被重写的函数不能是 static 的。必须是 virtual 的 ( 即函数在最原始的基类中被声明为 virtual ) 。

      • 2) 重写函数必须有相同的类型，名称和参数列表 (即相同的函数原型)

      • 3) 重写函数的访问修饰符可以不同。尽管 virtual 是 private 的，派生类中重写改写为 public,protected 也是可以的

    • 重载 (overload):
      指函数名相同，但是它的参数表列个数或顺序，类型不同。但是不能靠返回类型来判断。

    • 重定义 (redefining):
      子类重新定义父类中有相同名称的非虚函数 ( 参数列表可以不同 ) 。

  7. 重写与重载的区别 (override) PK (overload)

    • 方法的重写是子类和父类之间的关系，是垂直关系；方法的重载是同一个类中方法之间的关 系，是水平关系。

    • 重写要求参数列表相同；重载要求参数列表不同。

    • 重写关系中，调用那个方法体，是根据对象的类型（对象对应存储空间类型）来决定；重载关系，是根据调用时的实参表与形参表来选择方法体的。

12. binding

  1. 对象的静态类型：对象在声明时采用的类型。是在编译期确定的。

  2. 对象的动态类型：目前所指对象的类型。是在运行期决定的。对象的动态类型可以更改，但是静态类型无法更改。

    D* pD = new D();
//pD的静态类型是它声明的类型D*，动态类型也是D*  
B* pB = pD;
//pB的静态类型是它声明的类型B*，动态类型是pB所指向的对象pD的类型D*  
C* pC = new C();  
pB = pC;
//pB的动态类型是可以更改的，现在它的动态类型是C*
  3. 静态绑定：绑定的是对象的静态类型，某特性（比如函数）依赖于对象的静态类型，发生在编译期。
  4. 动态绑定：绑定的是对象的动态类型，某特性（比如函数）依赖于对象的动态类型，发生在运行期。
  5. 只有虚函数是动态绑定，其余函数都是静态绑定。动态绑定的函数调用的函数体看实际上的对象类型，静态绑定的函数调用的函数体看声明的对象类型。
  6. 虚函数是动态绑定的，但是为了执行效率，缺省参数是静态绑定的。

13. upcasting、downcasting与类指针

  1. 将基类引用转换为派生类引用称为upcasting，因为在继承图上式上升的。

  2. 对于一个使用了虚函数的基类来说：

    Base b = d;//直接赋值（产生切割）  
b.Test();  

Base& b2 = d;//使用引用赋值（不产生切割）  
b2.Test();  
Base* b3 = &d;//使用指针赋值（不产生切割）  
b3->Test();  

//覆盖方法和子类数据丢失的现象生成切割(slice)

14. 模板

  1. 模板的一般形式：

    Template <class或者也可以用typename T>

返回类型 函数名（形参表）
{//函数定义体 }

//template是一个声明模板的关键字，表示声明一个模板关键字class不能省略，如果类型形参多余一个 ，每个形参前都要加class <类型 形参表>可以包含基本数据类型可以包含类类型.

template <class T>  
inline T square(T x)  
{  
   T result;  
   result = x * x;  
   return result;  
};

15. 异常探查

http://www.cnblogs.com/ggjucheng/archive/2011/12/18/2292089.html

16. explicit

Test1 t1=12;//隐式调用其构造函数,成功
Test2 t2=12;//编译错误,不能隐式调用其构造函数
Test2 t2(12);//显式调用成功

explicit可以避免隐式调用构造函数。

17. 友元函数

class A{
    friend int print(); //友元函数不可被继承
}

int print(){}; //可以定义在类内或者类外

int main{
    A obj;
    print(); //可以直接调用友元函数
}
zjugeek
关注
Jumping_into_c++
03-22
一、C++编程初探与开发环境搭建 C++是一种通用、面向对象的编程语言，由Bjarne Stroustrup于1983年在贝尔实验室创建，旨在增强C语言的功能性。C++不仅保留了C语言的所有特性，还引入了类、模板、命名空间等高级概念...
C++入门:三小时看完最基础语句，手动写一个满是BUG的管理系统
soulproficiency的博客
02-10 239
因为下学期有门课需要使用C++，万般无奈开始了基础的学习，本篇文章主要记录自己的学习经历与心得，文末会附上.cpp文件。
C++进阶语法——OOP（面向对象编程）【C++深度学习部署（四）】
qq_23022733的博客
10-27 1008
----->• 在析构函数中释放内存时，其他对象中的指针可能还在指向被释放的资源，在析构函数释放内存资源时可能会报错，例如下面的代码，如果使用编译器默认的拷贝构造函数，在进行析构函数释放内存资源时可能会报错。当调用析构函数的时候，由于后进先出的原则，new_account 上的地址被释放后，alice_account 的地址也会被释放，但地址已经被释放，所以会造成堆空间重复释放的问题，导致程序报错，------>• 如果是指针，拷⻉的是值（指向的地址），⽽不是指向的对象，
[ C++ ] 带你一篇了解什么是OOP(面向对象编程)，什么是封装？ -- 类与对象（上）
CSDN博客
05-13 4170
学习过C语言的小伙伴知道：C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。 面向过程编程也叫结构化编程。虽然结构化编程的理念提高了程序的清晰度，可靠性，并且方便维护。但它再编写大型的程序时，仍然面临这巨大的挑战，OOP(面向对象编程)提供了一种新的方法。与强调算法的过程性编程不同的是，OOP强调的是数据。--引自《C++ Primer Plus(第六版)》 1.面向对象编程 C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。
Python3 OOP（三） 继承和多态
weixin_30664539的博客
07-11 79
class Animal(object): def run(self): print('Animal is running...') class Dog(Animal): pass class Cat(Animal): pass 　　对于Dog来说，Animal就是它的父类，对于Animal来说，Dog就是它的子类。Cat和Do...
python3 oop面向对象编程入门
walk on the road of linux
11-13 262
class Beartoy: #新建一个类 def __init__(self, name, size, color): #定义方法，用于创建实例用 self.name = name self.size = size self.color = color if __name__ == '__main__': b1 = Beartoy('Tidy'.
iphone开发初探
07-24
Objective-C是在C语言的基础上扩展的，增加了面向对象编程（OOP）的功能。它的核心仍然是C语言，但具备了像Java一样的垃圾回收机制，不过由于iPhone平台资源有限，iOS开发中并不支持垃圾回收。 学习Objective-C，...
C++源码 MyPlayer.zip
10-27
《C++源码解析——MyPlayer.zip初探》 C++是一种强大且广泛应用的编程语言，尤其在系统软件、游戏开发、嵌入式系统以及高性能计算等领域占据着重要地位。对于初学者而言，掌握C++的基本语法和编程理念至关重要。...
哈尔滨工业大学C++进阶编码讲义
10-07
9. **C++对象模型初探_20050323_chenru.ppt** - C++对象模型深入介绍了C++内存布局、对象生命周期、虚函数表等底层机制，是理解C++运行时行为的关键。 通过这些讲义的学习，学员不仅可以提升C++编程技能，还能了解...
Hola-mundo2
03-31
《C++编程初探：Hola Mundo到复杂世界》 在编程的世界里，"Hola Mundo"（你好，世界）是每个新手程序员踏入编程的第一步。它简单而经典，就像乐谱上的第一个音符，引领我们进入代码的海洋。在这个关于"C++"的教程中...
如何用C语言实现OOP
编程与实战的博客
06-24 1757
我们知道面向对象的三大特性分别是：封装、继承、多态。很多语言例如：C++ 和 Java 等都是面向对象的编程语言，而我们通常说 C 是面向过程的语言，那么是否可以用 C 实现简单的面向对象...
c++中面向对象oop中的类定义
爱吃的栗子‘s 博客
12-10 350
定义类一般来说类规范有两个部分组成 类声明：以数据成员的方式描述数据部分，以成员函数的方式（又被成为方法）来描述公有接口。 类方法定义：如何实现类成员函数。 类声明： #ifndef PCH_H #define PCH_H #include <iostream> #include <string> class students { private: in...
C语言编程能改写Cpp不,OOP面向对象编程：由C语言到C++
weixin_42393621的博客
05-23 323
链接：https://www.cnblogs.com/whale90830/p/10488595.html由C到C++OOP第一课C语言的局限C++的特点C++的程序特征C++程序的结构特性C++程序的编辑、编译和运行⭐C++对C的补充C语言的局限类型检查机制相对较弱，使得程序中的一些错误不能在编译时由编译器检查出来。C语言本身没有支持代码重用的语言结构不适合开发大型程序，当程序的规模达到一定的程...
OOP（面向对象知识点梳理）
陈小鹏的学习笔记
12-09 419
这是一张Java OOP学习的知识点大纲
【c++ oop】面向对象编程学习整理
isanth
08-02 613
文章目录面向对象编程内联函数（inline）构造函数（constructor）参数的值传递和引用传递友元操作符重载拷贝构造函数、拷贝赋值函数和析构函数栈、堆、内存分配内存分配demo 代码堆、栈static 成员类之间的关系复合（composition）委托（aggregation; composition by reference）继承（extension）虚函数面向对象设计范例使用委托 + 继承实现 Observer 模式使用委托+继承实现 Composite 模式使用委托+继承实现 Prototype
Python3 OOP（一） 类和实例
weixin_30786617的博客
07-11 290
定义类 #定义类是通过class关键字 class Student(object): pass 创建实例 #通过类名+()实现的 obj = Student()obj.name = '绑定属性'print(obj.name) #绑定属性 　　可以在创建实例的时候，把一些我们认为必须绑定的属性强制填写进去。通过定义一个特殊的__init__方法，在创建实例的...
基于SSM的众筹平台网站.zip
11-01
基于SSM的毕业设计源码
安徽省、市、区县及街镇可编辑SVG图
11-01
安徽省、市、区县及街镇可编辑SVG图
AppDynamics自动化与脚本教程.docx
最新发布
11-01
AppDynamics自动化与脚本教程
TwinCAT3 OOP编程进阶技巧与例程解析
资源摘要信息:"本资源是一份关于工业自动化中TwinCAT3软件平台的OOP（面向对象编程）编程进阶例程文档。TwinCAT3是Beckhoff公司开发的一款软件解决方案，用于在Microsoft Windows平台上实现工业控制系统的编程和运行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值