C++继承与派生

最新推荐文章于 2024-09-11 11:20:58 发布
最新推荐文章于 2024-09-11 11:20:58 发布
阅读量1.1k 收藏 15
点赞数 42
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36816794/article/details/140257301
版权

1. 引入

在C++中可重用性是通过继承这一机制来实现的，继承是类与对象的精华

1.1. 归类

对于学生和老师进行归类
在这里插入图片描述

1.2. 抽取

在这里插入图片描述

1.3. 继承

在这里插入图片描述

1.4. 重用

// C++通过继承关系，实现了代码的可重用性
// 父类 共性
class Human
{
public:
  void eat(string food)
  {
    cout << "i am eating " << food << endl;
  }
};
// 子类 在父类的基础上增加新的功能，体现的是个性
class Student : public Human
{
public:
  void study(string course)
  {
    cout << "i am a student , i am learning " << course << endl;
  }
};
class Teacher : public Human
{
public:
  void teach(string course)
  {
    cout << "i am a teacher , i am teaching " << course << endl;
  }
};
int main()
{
  Student s;
  s.study("c++");
  s.eat("排骨饭");
  Teacher t;
  t.teach("java");
  t.eat("大盘鸡");
  return 0;
}

2. 定义

类的继承，是新的类从已有类那里得到已有的特性。或从已有类产生新类的过程，就是类的派生。原有的类称为基类或父类，产生的新类称为派生类或子类。
派生与继承，是同一种意义两种称谓

3. 继承

3.1. 关系定性is-a/has-a

is-a是一种属于关系，在面向对象中表现为一种继承关系。
has-a是一种包含、组合关系。
is-a这种关系可以完成代码复用，是继承。把比较抽象的类作为基类而做出派生类。
因此，如果A是B，则B是A的基类，A是B的派生类。为继承关系。
has-a这种关系可以把一个复杂的类处理为一个个相对简单的类，是聚合。每个类本身相对简单，通过聚合(组合)成为一个复杂的类
因此，如果A包含B，则B是A的组成部分。为聚合关系，可以由组成部分聚合成为一个类

3.2. 语法

派生类的声明

class 派生类名:[继承方式] 基类名
{
	派生类成员声明;
}

一个派生类可以同时有多个基类，这种情况称为多重继承，派生类只有一个基类，称为单继承。

3.3. 继承方式

继承方式规定了如何访问基类继承的成员。继承方式有public、private和protected。继承方式不影响派生类的访问权限，影响了从基类继承来的成员的访问权限，包括派生类内的访问权限和派生类对象。
简单讲：
公有继承：基类的公有成员和保护成员在派生类中保持原有访问属性，其私有成员仍为基类的私有成员
私有继承：基类的公有成员和保护成员在派生类中成了私有成员，其私有成员仍为基类的私有成员
保护继承：基类的公有成员和保护成员在派生类中成了保护成员，其私有成员仍为基类的私有成员
protected对于外界访问属性来说，等同于私有，但可以派生类中可见

class Father
{
public:
  int x;

protected:
  int y;

private:
  int c;
};

class Son : public Father
{
public:
  int pub;
  void func()
  {
    x = 3; // 可以访问基类的public成员
    y = 4; // 可以访问基类的protected成员
    // c = 5; // Error: 无法访问基类的private成员
  }

protected:
  int pro;

private:
  int pri;
};

// public继承方式，父类中的public成员在子类中依然是public，
// protected成员在子类中依然是protected，
// private成员无法在子类中访问。
#if 0
Father   public
pub      pub(public)
pro      pro(protected)
pri      inacceess
#endif

int main()
{
  Son s;
  s.pub; // 可以访问public成员
  // s.pro; // Error: 无法访问protected成员
  // s.pri; // Error: 无法访问private成员
  s.x = 100; // 可以访问基类的public成员
  // s.y = 200; // Error: 无法访问基类的protected成员
  return 0;
}

3.4. 派生类的组成

派生类的成员，包含两大部分，一类是从基类继承的，一类是自己增加的成员。从基类继承过来的表现其共性，而新增的成员体现其个性
在这里插入图片描述
说明：

  1. 全盘接收：除了构造器和析构器。基类有可能会造成派生类的成员冗余，所以说基类是需设计的
  2. 派生类有自己的个性，才使派生有意义
class A
{
public:
  A()
  {
    cout << this << endl;
    cout << typeid(this).name() << endl;
  }
  int a;
};
class B : public A
{
public:
  B()
  {
    cout << this << endl;
    cout << typeid(this).name() << endl;
  }
  int b;
};
class C : public B
{
public:
  C()
  {
    cout << this << endl;
    cout << typeid(this).name() << endl;
  }
  void func()
  {
    cout << &a << endl; // 0x16d0aedb0 P1A
    cout << &b << endl; // 0x16d0aedb0 P1B
    cout << &c << endl; // 0x16d0aedb0 P1C
  }
  int c;
};
int main()
{
  C c;
  cout << "&c " << &c << endl; // &c 0x16d0aedb0
  cout << "********" << endl;
  c.func();
  return 0;
}

4. 派生类的构造

派生类中由基类继承而来的成员的初始化工作还是由基类的构造函数完成，然后派生类中新增的成员在派生类的构造函数中初始化。

4.1. 派生类构造函数的语法

派生类名::派生类名(参数总表) 
	:基类名(参数表), 内嵌子对象(参数表)
{
	派生类新增成员的初始化语句; // 也可出现参数列表中
}

注：

  • 构造函数的初始化顺序并不以上面的顺序进行，而是根据声明的顺序初始化
  • 如果基类中没有默认构造函数(无参)，那么在派生类的构造函数中必须显示调用基类构造函数，以初始化基类成员
  • 派生类构造函数执行的次序：基类->成员->子类
    • 调用基类构造函数，调用顺序按照他们被继承时声明的顺序(从左到右)
    • 调用内嵌成员对象的构造函数，调用顺序按照他们在类中声明的顺序
    • 派生类的构造函数体中的内容

4.2. 代码实现

  • 祖父类
    student.h
#ifndef STUDENT_H
#define STUDENT_H

#include <iostream>
using namespace std;

class Student
{
public:
  Student(string sn, int ia, float fs);
  void dis();

private:
  string name;
  int age;
  float score;
};

#endif

student.cpp

#include "student.h"

Student::Student(string sn, int ia, float fs)
    : name(sn), age(ia), score(fs)
{
}

void Student::dis()
{
  cout << "name: " << name << " age: " << age << " score: " << score << endl;
}
  • 父类
    graduate.h
#ifndef GRADUATE_H
#define GRADUATE_H

#include "student.h"
#include "birthday.h"

class Graduate : public Student
{
public:
  Graduate(string sn, int ia, float fs, double ds, int iy, int im, int id);
  void print();
  void getBirth();

private:
  double salary;
  Birthday birth;
};

#endif

graduate.cpp

#include "graduate.h"

Graduate::Graduate(string sn, int ia, float fs, double ds, int iy, int im, int id)
    : Student(sn, ia, fs), salary(ds), birth(iy, im, id)
{
}
void Graduate::print()
{
  dis(); // name age score public
  cout << "salary: " << salary << endl;
}

void Graduate::getBirth()
{
  birth.dis();
}
  • 类成员
    birthday.h
#ifndef BIRTHDAY_H
#define BIRTHDAY_H

#include <iostream>
using namespace std;

class Birthday
{
public:
  Birthday(int y, int m, int d);
  void dis()
  {
    cout << "Birthday: " << year << "/" << month << "/" << day << endl;
  }

private:
  int year;
  int month;
  int day;
};

#endif

birthday.cpp

#include "birthday.h"

Birthday::Birthday(int y, int m, int d)
    : year(y), month(m), day(d)
{
}
  • 子类
    doctor.h
#ifndef DOCTOR_H
#define DOCTOR_H
#include "graduate.h"

class Doctor : public Graduate
{
public:
  Doctor(string sn, int ia, float fs, double ds, int iy, int im, int id, string st);
  // public dis => public  public print => public
  void dump()
  {
    print();
    cout << "title: " << title << endl;
  }

private:
  string title;
};

#endif

doctor.cpp

#include "doctor.h"

Doctor::Doctor(string sn, int ia, float fs, double ds, int iy, int im, int id, string st)
    : Graduate(sn, ia, fs, ds, iy, im, id), title(st)
{
}
  • 测试代码
#include "student.h"
#include "graduate.h"
#include "doctor.h"
int main()
{
  Student s("wyb", 27, 18.8);
  s.dis();
  Graduate g("xz", 32, 22, 10000, 1999, 9, 9);
  g.print();
  g.getBirth();
  Doctor d("lj", 23, 200, 200000, 1999, 9, 9, "doctor l");
  d.dump();

  return 0;
}

4.3. 结论

子类构造器中，要么显示的调用父类的构造器(传参)，要么隐式的调用。发生隐式调用时，父类要有无参构造器或是可以包含无参构造器的默认参数函数。子类对象亦然

5. 派生类的拷贝构造

5.1. 格式

派生类::派生类(const 原生类 &another) 
    :基类(another), 派生类新成员(another, 新成员)
{
}

5.2. 代码

  • 父类
    student.h
class Student
{
public:
    Student(string sn, int n, char s);
    Student(const Student &another);
    ~Student();
    void dis();

private:
    std::string name;
    int num;
    char sex;
};

student.cpp

Student::Student(string sn, int n, char s)
    : name(sn), num(n), sex(s)
{
}
Student::~Student()
{
}
void Student::dis()
{
    cout << name << endl;
    cout << num << endl;
    cout << sex << endl;
}
Student::Student(const Student &another)
{
    name = another.name;
    num = another.num;
    sex = another.sex;
}
  • 子类
    graduate.h
class Graduate : public Student
{
public:
    Graduate(string sn, int in, char cs, float fs);
    ~Graduate();
    Graduate(const Graduate &another);
    void dump()
    {
        dis();
        cout << salary << endl;
    }

private:
    float salary;
}

graduate.cpp

Graduate::Graduate(string sn, int in, char cs, float fs)
    : Student(sn, in, cs), salary(fs)
{
}
Graduate::~Graduate()
{
}
Graduate::Graduate(const Graduate &another)
    : Student(another), salary(another.salary)
{
}
  • 测试代码
int main()
{
    Graduate g("wyb", 2001, 'x', 2000);
    g.dump();
    Graduate gg = g;
    gg.dump();
    return 0;
}

5.3. 结论

派生类中的默认拷贝构造器会调用父类中默认或自实现拷贝构造起，若派生类中自实现拷贝构造器，则必须显式的调用父类的拷贝构造器

6. 派生类的赋值运算符重载

赋值运算符函数不是构造器，所以可以继承，语法上就没有构造器的严格

6.1. 格式

子类 &子类::operator=(const 子类 &another)
{
    if (this == &another)
        return *this; // 防止自赋值
    父类::operator=(another); // 调用父类的赋值运算符重载
    this->salary = another.salary; // 子类成员初始化
    return *this;
}

6.2. 代码

  • 基类
    student.h
Student &operator=(const Student &another);

student.cpp

Student &Student::operator=(const Student &another)
{
    this->name = another.name;
    this->num = another.num;
    this->sex = another.sex;
    return *this;
}
  • 派生类
    graduate.h
Graduate &operator=(const Graduate &another);

graduate.cpp

Graduate &Graduate::operator=(const Graduate &another)
{
    if (this == &another)
        return *this;
    Student::operator=(another);
    this->salary = another.salary;
    return *this;
}
  • 测试代码
int main()
{
    Graduate g("wyb", 2001, 'x', 2000);
    g.dump();
    Graduate gg = g;
    gg.dump();
    cout << "-------" << endl;
    Graduate ggg("xz", 2002, 'x', 2000);
    ggg.dump();
    ggg = g;
    ggg.dump();
    return 0;
}

6.3. 结论

派生类的默认赋值运算符重载函数，会调用父类的默认或自实现函数。派生类若自实现，则不会发生调用行为，也不报错(区别拷贝)，赋值错误，若要正确，需要显式的调用父类的构造器

7. 派生类友元函数

由于友元函数并非类成员，因而不能被继承，在某种需求下，可能希望派生类的友元函数能够使用基类中的友元函数。为此可以通过强制类型转换，将派生类的指针或是引用强转为其类的引用或指针，然后使用转换后的引用或指针来调用基类中的友元函数

class Student
{
    friend ostream &operator<<(ostream &os, Student &stu);

private:
    int a;
    int b;
};
ostream &operator<<(ostream &os, Student &stu)
{
    out << stu.a << " " << stu.b << endl;
}
class Graduate : public Student
{
    friend ostream &operator<<(ostream &os, Graduate &gra);

private:
    int c;
    int d;
};
ostream &operator<<(ostream &os, Graduate &gra)
{
    out << (Student &)gra << endl;
    out << gra.c << " " << gra.d << endl;
}
int main()
{
    Student a;
    cout << a << endl;
    Graduate g;
    cout << g << endl;
    return 0;
}

8. 派生类析构函数的语法

派生类的析构函数的功能是在该对象消亡之前进行一些必要的清理工作，析构函数没有类型，也没有参数。析构函数的执行顺序与构造函数相反。

  • 析构顺序
子类->成员->基类

无需指明析构关系，析构函数只有一种，无重载，无默认参数

9. 派生类成员的标识和访问

9.1. 作用域分辨符

  • 格式
基类名::成员名; 基类名::成员名(参数表);

如果某派生类的多个基本拥有同名的成员，同时，派生类又新增这样的同名成员，在这种情况下，派生类成员将shadow(隐藏)所有基类的同名成员。这就需要这样的调用方式才能调用基类的同名成员

class Base
{
public:
    void func(int)
    {
        cout << "func" << endl;
    }
};
class Derived : public Base
{
public:
    void func()
    {
        // func(); // func 死循环
        // Base::func(); // 被shadow的成员，可以这样访问
        cout << "Derived::func" << endl;
    }
};
int main()
{
    Derived d;
    d.func(); // 访问派生类成员
    // d.Base::func(3); // 访问基类成员
    return 0;
}
  • 小结
    重载：同一作用域，函数同名不同参(个数、类型、顺序)
    隐藏：父子类中，标识符(函数、变量)相同，无关乎返值和参数(函数)，或声明类型(变量)

9.2. 继承方式

9.2.1. 图示

在这里插入图片描述
在这里插入图片描述

9.3. 派生类成员属性划分

四种：公有成员、保护成员、私有成员；不可访问的成员

class Base
{
public:
    int pub;

protected:
    int pro;

private:
    int pri;
};
class Drive : public Base
{
public:
    void func()
    {
        pub = 10;
        pro = 100;
        // pri = 1000;
    }
};
int main()
{
    Base b;
    b.pub = 10;
    // b.pro = 100;
    // b.pri = 1000;
    return 0;
}

10. why public

10.1. 公有继承的意义

class Base
{
public:
    int pub;

protected:
    int pro;

private:
    int pri;
};
class Drvie : public Base
{
public:
};

private 在子类中不可见，但仍可通过父类接口访问。
在这里插入图片描述
public 作用：传承接口 间接的传承了数据(protected)。
在这里插入图片描述
protected 作用：传承数据，间接封杀了对外接口。
在这里插入图片描述
private 统杀了数据和接口

  1. 只要是私有成员到派生类中，均不可访问。正是体现的数据隐藏性，其私有成员仅可被本类的成员函数访问
  2. 如果多级派生当中，均采用public，直到最后一级，派生类中均可访问基类的public、protected成员。
    兼顾了数据的隐藏性和接口传承和数据传递
  3. 如果多级派生当中，均采用private，直到最后一级，派生类中基类的所有成员均变为不可见。
    只兼顾了数据的隐藏性
  4. 如果多级派生当中，均采用protected，直到最后一级，派生类的基类的所有成员即使可见，也均不可被类外调用。
    只兼顾了数据的隐藏性和数据传递
    综上所述：记住public足矣

10.3. 使用Qt类库

#ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include <QMainWindow>
class MainWindow : public / protected / private QMainWindow
{
    Q_OBJECT
public:
    MainWindow(QWidget *parent = 0);
    ~MainWindow();
};
#endif

10.4. 使用私有继承和保护继承存在意义

此两种方式有效的防止了基类公有接口的扩散，是一种实现继承，而不是一种单独的is-a的关系了。

class Windows
{
public:
    一般常见基础接口
protected:
    常用特效接口
    高级特效接口
private:
    duang特效接口
};

11. 多继承

从继承类别上分，继承可分为单继承和多继承。

11.1. 继承语法

派生类名::派生类名(参数总表)
    :基类名1(参数表1), 基类名2(参数表2), ...基类名n(参数表n)
    内嵌子对象1(参数表1), 内嵌子对象2(参数表2), ...内嵌子对象n(参数表n)
{
    派生类新增成员的初始化语句;
}

11.2. 代码

  • 床类
    bed.h
#ifndef BED_H_
#define BED_H_

class Bed
{
public:
    Bed();
    void sleep();
};

#endif

bed.cpp

#include "bed.h"
#include <iostream>
using namespace std;

void Bed::sleep()
{
    cout << "Sleeping in bed" << endl;
}
  • 沙发类
    sofa.h
#ifndef _SOFA_H_
#define _SOFA_H_

class Sofa
{
public:
    Sofa();
    void sit();
};
#endif // _SOFA_H_

sofa.cpp

#include "sofa.h"
#include <iostream>
using namespace std;

Sofa::Sofa() {}
void Sofa::sit()
{
    cout << "Sofa is sitting" << endl;
}
  • 沙发床类
    sofabed.h
#ifndef SOFABED_H
#define SOFABED_H

#include "bed.h"
#include "sofa.h"

class SofaBed : public Bed, public Sofa
{
};
#endif // SOFABED_H

sofabed.cpp

#include "sofabed.h"
  • 测试代码
    main.cpp
#include "sofa.h"
#include "bed.h"
#include "sofabed.h"
int main10()
{
    Sofa sf;
    sf.sit();
    Bed bed;
    bed.sleep();
    SofaBed sb;
    sb.sleep();
    sb.sit();
    return 0;
}

11.3. 三角问题(二义性问题)

多个父类中重名的成员，继承到子类中后，为了避免冲突，携带了各父类的作用域信息，子类中要访问继承下来的重名成员，则会产生二义性，为了避免冲突，访问时需要还有父类的作用域信息。

class X
{
public:
    X(int d) : _data(d) {}
    void setData(int i)
    {
        _data = i;
    }
    int _data;
};
class Y
{
public:
    Y(int d) : _data(d) {}
    int getData()
    {
        return _data;
    }
    int _data;
};
class Z : public X, public Y
{
public:
    Z() : X(2), Y(3) {}
    void dis()
    {
        cout << X::_data << endl;
        cout << Y::_data << endl;
    }
};
int main()
{
    Z z;
    z.dis();
    z.setData(5);
    cout << z.getData() << endl;
    return 0;
}

11.4. 钻石问题

11.4.1. 三角转四角

采用提取公因式的方法

class M
{
public:
    M(int i) : _data(i)
    {
    }
    int _data;
};
class X : public M
{
public:
    X(int d) : M(d)
    {
    }
    void setData(int i)
    {
        _data = i;
    }
};
class Y : public M
{
public:
    Y(int d) : M(d)
    {
    }
    int getData()
    {
        return _data;
    }
};
class Z : public X, public Y
{
public:
    Z() : X(2), Y(3)
    {
    }
    void dis()
    {
        cout << X::_data << endl;
        cout << Y::_data << endl;
    }
};
int main()
{
    Z z;
    z.dis();
    z.setData(2000);
    cout << z.getData() << endl;
    return 0;
}

11.4.2. 虚继承

class M
{
public:
    M(int i) : _data(i)
    {
    }
    int _data;
};
class X : virtual public M
{
public:
    X(int d) : M(d)
    {
    }
    void setData(int i)
    {
        _data = i;
    }
};
class Y : virtual public M
{
public:
    Y(int d) : M(d)
    {
    }
    int getData()
    {
        return _data;
    }
};
class Z : public X, public Y
{
public:
    Z(int _x, int _y): X(_x), Y(_y), M(100) 
    {
    }
    void dis()
    {
        cout << X::_data << endl;
        cout << Y::_data << endl;
    }
};
int main()
{
    Z z;
    z.dis();
    z.setData(2000);
    cout << z.getData() << endl;
    return 0;
}

11.4.3. 小结

  • 虚继承的意义
    在多继承中，保存共同基类的多份同名成员，虽然有时是不必要的，可以在不同的数据成员中分别存放不同的数据，但在大多数情况下，是我们不希望出现的，因为保存多份数据成员的拷贝，不仅占有较多的存储空间，还增加了访问困难。
    为此，C++提供了虚基类和虚继承机制，实现了在多继承中只保留一份共同成员。
    虚继类，需要设计和抽象，虚继承，是一种继承的扩展
  • 语法总结
  1. M类称为虚基类，是抽象和设计的结果
  2. 虚继承语法
class 派生类名:virtual 继承方式 基类
  1. 虚基类及间接类的实例化
class A
{
    A(int i)
    {
    }
};
class B : virtual public A
{
    B(int n) : A(n)
    {
    }
};
class C : virtual public A
{
    C(int n) : A(n)
    {
    }
};
class D : public B, public C
{
    D(int n) : A(n), B(n), C(n)
    {
    }
};
Qi妙代码
关注
  • 42
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
C++ 继承与派生
PFzcnds8310__的博客
03-21 341
三 继承与派生 1.继承和派生的概念 一个新类从已有的类中获得其属性和方法，这种现象称为类的 继承。 从已有的类产生新的子类的现象，称为类的 派生。 被继承的类称为 基类，派生的类称为 派生类或子类。 派生类是抽象基类的实例。 2.派生类的声明 公用继承 class student1:public student 私有继承 class student1:private student 保护继承...
c++ 继承与派生
m0_61650789的博客
05-12 1077
c++ 继承与派生
C++继承与派生总结
Qiao712的博客
06-22 1489
面向对象程序设计基于数据抽象、继承、动态绑定这三个基本概念。 OOP的核心思想：多态性(polymorphism) 继承(inheritance) 基类(base class) 直接基类(direct base) 间接基类(indirect base) 派生类(derived class) 虚函数(virtual function) 其解析过程发生在运行时，而不是编译时 类派生列表(class derivation list) 动态绑定(dynamic binding) 使用基类的引用或指针调用一个虚成员
C++面向对象程序设计习题继承与派生.pdf
09-30
"C++面向对象程序设计习题继承与派生.pdf" 继承是面向对象程序设计中的一种重要机制，它允许一个类继承另一个类的属性和行为特征。通过继承，新类可以从现有类中获得特征，从而达到代码复用的目的。在C++中，继承...
c++继承与派生
01-19
C++继承与派生 本节课程主要介绍C++中继承与派生的概念和使用方法，包括公有继承、私有继承和保护继承等不同的继承方式。通过实验和实践，掌握继承与派生的基本概念和使用方法。 继承的概念 继承是面向对象编程中...
C++继承与派生类习题.docx
02-27
综上所述，C++的继承与派生提供了构建复杂类层次结构的能力，通过合理设计继承关系，可以有效地组织和重用代码，提高软件的可维护性和可扩展性。同时，需要注意继承带来的访问权限变化、二义性问题以及构造与析构...
【C++】CLion配置cout打印语句快捷键
qq_38196449的博客
09-10 191
当我们sout时，自动出现打印语句。点击Apply 和 OK 保存。
C语言 | Leetcode C语言题解之第389题找不同
m0_59237910的博客
09-07 536
C语言 | Leetcode C语言题解之第389题找不同
C语言作用域
天道酬勤
09-07 979
作用域 (scope) 是描述程序可以访问标识符的区域。块是一对花括号 {} 括起来的区域 或 函数体内任意复合语句定义范围内的区域。定义在块中的变量具有块作用域。块作用域的变量的可见范围从定义处开始到该块定义范围的末尾为止。函数作用域是在整个函数体内可见的意思，在 C 程序中，函数形参和 goto 语句的标签具有函数作用域，在整个函数体内可见。在所有函数外定义的变量具有全局作用域，在整个程序都可见。在数据类型前加 static 关键字定义的全局变量具有文件作用域。
C语言——strcpy、sprintf与memcpy
鲸落博客
09-09 1083
该函数和printf()函数有很多相似之处，例如printf()将不同类型的数据格式化到终端，而sprintf()函数是将不同类型的数据格式化到字符串中。另外，和strcpy()函数一样，该函数也不会对目标缓冲区进行检查，容易造成溢出。它是一种非常通用的内存复制函数，不仅限于复制字符串，还可以复制任何类型的内存块。3. 未定义行为：程序可能会继续运行，但结果不可预测，可能会输出错误的结果或导致其他未预料的行为。如果memcpy复制字符串，要复制的字节数超过原内存块本身的内存数，会怎么样？
QWidget(c++)嵌入window环境的exe
sunflower_2020的博客
09-05 303
QWidget(c++)嵌入window环境的exe
C语言初阶 --- ⾃定义类型：结构体
2301_79842589的博客
09-08 952
💫往期文章👇：
C和指针：标准函数库
暮色年华的博客
09-11 467
longjmp 函数:一旦在程序的其他部分遇到了 longjmp 调用，并且传入了之前 setjmp 初始化的 jmp_buf 数组以及一个非零值作为跳转值，那么程序的控制就会立即跳回到与那个 jmp_buf 关联的 setjmp 处。setjmp 函数：一个函数中调用 setjmp 并传递一个类型为 jmp_buf 的数组作为参数时，setjmp 将会保存当前程序执行环境的一个快照（包括处理器寄存器和程序计数器等状态信息）到这个 jmp_buf 数组中。如果在某个低层的函数中检测到一个错误，你可以立。
完全背包（C++）
最新发布
lim6ere的博客
09-11 672
DP42 【模板】完全背包以上就是今天要讲的内容，本文仅仅详细介绍了。希望对大家的学习有所帮助，仅供参考 如有错误请大佬指点我会尽快去改正 欢迎大家来评论~~ 😘 😘 😘。
c++ 类的继承详解
HJQD777的博客
09-07 490
继承允许类之间建立层次关系，促进代码重用和扩展。继承有不同的访问控制方式（publicprotectedprivate），影响派生类对基类成员的访问权限。基类的构造函数和析构函数不会被继承，派生类需要自行定义。使用虚函数和多态可以实现灵活的接口设计和动态方法调用。理解继承机制对于设计高效、灵活和可维护的面向对象系统至关重要。
C++ #include ＜cstring＞（详解）
qq_51753728的博客
09-08 969
是在 C++ 程序中引入头文件<cstring>的语句。这个头文件提供了用于处理 C 风格字符串（即以空字符'\0'结尾的字符数组）的函数。具体来说，<cstring>（1）strcpystrcpy是cstring中用于复制 C 风格字符串的函数，它将源字符串的内容复制到目标字符串中，包括末尾的空字符 ('\0'使用strcpy时需要确保目标数组有足够的空间来存放源字符串。source。
C++继承与派生详解
"继承与派生是C++中面向对象编程的重要概念，它允许我们创建新的类（派生类）基于已存在的类（基类），以实现代码的重用和扩展。继承使得派生类能够继承基类的属性和方法，同时可以添加新的特性或者覆盖原有的行为。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Qi妙代码

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值