【c++】类等基础知识

最新推荐文章于 2024-09-26 12:00:11 发布
最新推荐文章于 2024-09-26 12:00:11 发布
阅读量433 收藏 1
点赞数
分类专栏： 学习笔记 文章标签： c++ 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HITORANGE/article/details/122191909
版权

看菜鸟教程的疑惑

#include <iostream>

using namespace std;

class Line
{
public:
    int getLength(void);
    Line(int len);             // 简单的构造函数
    Line(const Line& obj);      // 拷贝构造函数
    ~Line();                     // 析构函数

private:
    int* ptr;
};

// 成员函数定义，包括构造函数
Line::Line(int len)
{
    cout << "调用构造函数" << endl;
    // 为指针分配内存
    ptr = new int;
    *ptr = len;
}

Line::Line(const Line& obj)
{
    cout << "调用拷贝构造函数并为指针 ptr 分配内存" << endl;
    ptr = new int;
    *ptr = *obj.ptr; // 拷贝值
}

Line::~Line(void)
{
    cout << "释放内存" << endl;
    delete ptr;
}
int Line::getLength(void)
{
    return *ptr;
}

void display(Line obj)
{
    cout << "line 大小 : " << obj.getLength() << endl;
}

// 程序的主函数
int main()
{
    cout << "line 1: " << endl;
    Line line1(10);
    cout << "line 2: " << endl;
    Line line2 = line1; // 这里也调用了拷贝构造函数
    cout << "display: " << endl;
    display(line1);
    display(line2);

    return 0;
}

在这里插入图片描述
构造函数直接实例化一个类line1
通过拷贝构造函数以line1的参数实例化一个line2
display方法返回的指针变量，每次调用该指针变量都会通过拷贝构造函数给该指针分配内存？
打印指针变量，可见每次指向length 10 的指针变量都不一样

int Line::getLength(void)
{
    cout << "ptr : " << ptr << endl;
    return *ptr;
}

在这里插入图片描述
类的其他知识
在这里插入图片描述
友元函数：

#include <iostream>

using namespace std;

class Box
{
    double width;
public:
    friend void printWidth(Box box);
    friend class BigBox;
    void setWidth(double wid);
};

class BigBox
{
public :
    void Print(int width, Box &box)
    {
        // BigBox是Box的友元类，它可以直接访问Box类的任何成员
        box.setWidth(width);
        cout << "Width of box : " << box.width << endl;
    }
};

// 成员函数定义
void Box::setWidth(double wid)
{
    width = wid;
}

// 请注意：printWidth() 不是任何类的成员函数
void printWidth(Box box)
{
    /* 因为 printWidth() 是 Box 的友元，它可以直接访问该类的任何成员 */
    cout << "Width of box : " << box.width << endl;
}

// 程序的主函数
int main()
{
    Box box;
    BigBox big;

    // 使用成员函数设置宽度
    box.setWidth(10.0);

    // 使用友元函数输出宽度
    printWidth(box);

    // 使用友元类中的方法设置宽度
    big.Print(20, box);

    getchar();
    return 0;
}

静态变量：

#include <iostream>
 
using namespace std;
 
class Box
{
   public:
      static int objectCount;
      // 构造函数定义
      Box(double l=2.0, double b=2.0, double h=2.0)
      {
         cout <<"Constructor called." << endl;
         length = l;
         breadth = b;
         height = h;
         // 每次创建对象时增加 1
         objectCount++;
      }
      double Volume()
      {
         return length * breadth * height;
      }
   private:
      double length;     // 长度
      double breadth;    // 宽度
      double height;     // 高度
};
 
// 初始化类 Box 的静态成员
int Box::objectCount = 0;
 
int main(void)
{
   Box Box1(3.3, 1.2, 1.5);    // 声明 box1
   Box Box2(8.5, 6.0, 2.0);    // 声明 box2
 
   // 输出对象的总数
   cout << "Total objects: " << Box::objectCount << endl;
 
   return 0;
}

C++ 内联函数是通常与类一起使用。如果一个函数是内联的，那么在编译时，编译器会把该函数的代码副本放置在每个调用该函数的地方。

对内联函数进行任何修改，都需要重新编译函数的所有客户端，因为编译器需要重新更换一次所有的代码，否则将会继续使用旧的函数。

如果想把一个函数定义为内联函数，则需要在函数名前面放置关键字 inline，在调用函数之前需要对函数进行定义。如果已定义的函数多于一行，编译器会忽略 inline 限定符。

在类定义中的定义的函数都是内联函数，即使没有使用 inline 说明符。

成员函数可以定义在类定义内部，或者单独使用范围解析运算符 :: 来定义。
在这里插入图片描述

继承：

// 基类
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); 
      }
};

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

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

继承多个基类：

// 基类 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;
}

重载：
在同一个作用域内，可以声明几个功能类似的同名函数，但是这些同名函数的形式参数（指参数的个数、类型或者顺序）必须不同。您不能仅通过返回类型的不同来重载函数。

#include <iostream>
using namespace std;
 
class printData
{
   public:
      void print(int i) {
        cout << "整数为: " << i << endl;
      }
 
      void print(double  f) {
        cout << "浮点数为: " << f << endl;
      }
 
      void print(char c[]) {
        cout << "字符串为: " << c << endl;
      }
};
 
int main(void)
{
   printData pd;
 
   // 输出整数
   pd.print(5);
   // 输出浮点数
   pd.print(500.263);
   // 输出字符串
   char c[] = "Hello C++";
   pd.print(c);
 
   return 0;
}

运算符重载 参数可以用this 传递

#include <iostream>
using namespace std;
 
class Box
{
   public:
 
      double getVolume(void)
      {
         return length * breadth * height;
      }
      void setLength( double len )
      {
          length = len;
      }
 
      void setBreadth( double bre )
      {
          breadth = bre;
      }
 
      void setHeight( double hei )
      {
          height = hei;
      }
      // 重载 + 运算符，用于把两个 Box 对象相加
      Box operator+(const Box& b)
      {
         Box box;
         box.length = this->length + b.length;
         box.breadth = this->breadth + b.breadth;
         box.height = this->height + b.height;
         return box;
      }
   private:
      double length;      // 长度
      double breadth;     // 宽度
      double height;      // 高度
};
// 程序的主函数
int main( )
{
   Box Box1;                // 声明 Box1，类型为 Box
   Box Box2;                // 声明 Box2，类型为 Box
   Box Box3;                // 声明 Box3，类型为 Box
   double volume = 0.0;     // 把体积存储在该变量中
 
   // Box1 详述
   Box1.setLength(6.0); 
   Box1.setBreadth(7.0); 
   Box1.setHeight(5.0);
 
   // Box2 详述
   Box2.setLength(12.0); 
   Box2.setBreadth(13.0); 
   Box2.setHeight(10.0);
 
   // Box1 的体积
   volume = Box1.getVolume();
   cout << "Volume of Box1 : " << volume <<endl;
 
   // Box2 的体积
   volume = Box2.getVolume();
   cout << "Volume of Box2 : " << volume <<endl;
 
   // 把两个对象相加，得到 Box3
   Box3 = Box1 + Box2;
 
   // Box3 的体积
   volume = Box3.getVolume();
   cout << "Volume of Box3 : " << volume <<endl;
 
   return 0;
}

operator是关键字operator关键字，和符号一起作为运算符函数
一元运算符重载实例：

#include <iostream>
using namespace std;
 
class Distance
{
   private:
      int feet;             // 0 到无穷
      int inches;           // 0 到 12
   public:
      // 所需的构造函数
      Distance(){
         feet = 0;
         inches = 0;
      }
      Distance(int f, int i){
         feet = f;
         inches = i;
      }
      // 显示距离的方法
      void displayDistance()
      {
         cout << "F: " << feet << " I:" << inches <<endl;
      }
      // 重载负运算符（ - ）
      Distance operator- ()  
      {
         feet = -feet;
         inches = -inches;
         return Distance(feet, inches);
      }
};
int main()
{
   Distance D1(11, 10), D2(-5, 11);
 
   -D1;                     // 取相反数
   D1.displayDistance();    // 距离 D1
 
   -D2;                     // 取相反数
   D2.displayDistance();    // 距离 D2
 
   return 0;
}

在这里插入图片描述
自定义某个类的容器：通过重载->操作符访问 成员类的方法

#include <iostream>
#include <vector>
using namespace std;
 
// 假设一个实际的类
class Obj {
   static int i, j;
public:
   void f() const { cout << i++ << endl; }
   void g() const { cout << j++ << endl; }
};
 
// 静态成员定义
int Obj::i = 10;
int Obj::j = 12;
 
// 为上面的类实现一个容器
class ObjContainer {
   vector<Obj*> a;
public:
   void add(Obj* obj)
   { 
      a.push_back(obj);  // 调用向量的标准方法
   }
   friend class SmartPointer;
};
 
// 实现智能指针，用于访问类 Obj 的成员
class SmartPointer {
   ObjContainer oc;
   int index;
public:
   SmartPointer(ObjContainer& objc)
   { 
       oc = objc;
       index = 0;
   }
   // 返回值表示列表结束
   bool operator++() // 前缀版本
   { 
     if(index >= oc.a.size() - 1) return false;
     if(oc.a[++index] == 0) return false;
     return true;
   }
   bool operator++(int) // 后缀版本
   { 
      return operator++();
   }
   // 重载运算符 ->
   Obj* operator->() const 
   {
     if(!oc.a[index])
     {
        cout << "Zero value";
        return (Obj*)0;
     }
     return oc.a[index];
   }
};
 
int main() {
   const int sz = 10;
   Obj o[sz];
   ObjContainer oc;
   for(int i = 0; i < sz; i++)
   {
       oc.add(&o[i]);
   }
   SmartPointer sp(oc); // 创建一个迭代器
   do {
      sp->f(); // 智能指针调用
      sp->g();
   } while(sp++);
   return 0;
}

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

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

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

#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 :" << 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 :" << 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;
}

纯虚函数

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 //告诉编译器，函数没有主体，上面的虚函数是纯虚函数。
};

C++中, 虚函数可以为private, 并且可以被子类覆盖（因为虚函数表的传递），但子类不能调用父类的private虚函数。虚函数的重载性和它声明的权限无关。

一个成员函数被定义为private属性，标志着其只能被当前类的其他成员函数(或友元函数)所访问。而virtual修饰符则强调父类的成员函数可以在子类中被重写，因为重写之时并没有与父类发生任何的调用关系，故而重写是被允许的。

编译器不检查虚函数的各类属性。被virtual修饰的成员函数，不论他们是private、protect或是public的，都会被统一的放置到虚函数表中。对父类进行派生时，子类会继承到拥有相同偏移地址的虚函数表（相同偏移地址指，各虚函数相对于VPTR指针的偏移），则子类就会被允许对这些虚函数进行重载。且重载时可以给重载函数定义新的属性，例如public，其只标志着该重载函数在该子类中的访问属性为public，和父类的private属性没有任何关系！

纯虚函数可以设计成私有的，不过这样不允许在本类之外的非友元函数中直接调用它，子类中只有覆盖这种纯虚函数的义务，却没有调用它的权利。

抽象类的实例
请看下面的实例，基类 Shape 提供了一个接口 getArea()，在两个派生类 Rectangle 和 Triangle 中分别实现了 getArea()：

实例


#include <iostream>
 
using namespace std;
 
// 基类
class Shape 
{
public:
   // 提供接口框架的纯虚函数
   virtual int getArea() = 0;
   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); 
   }
};
class Triangle: public Shape
{
public:
   int getArea()
   { 
      return (width * height)/2; 
   }
};
 
int main(void)
{
   Rectangle Rect;
   Triangle  Tri;
 
   Rect.setWidth(5);
   Rect.setHeight(7);
   // 输出对象的面积
   cout << "Total Rectangle area: " << Rect.getArea() << endl;
 
   Tri.setWidth(5);
   Tri.setHeight(7);
   // 输出对象的面积
   cout << "Total Triangle area: " << Tri.getArea() << endl; 
 
   return 0;
}
HI_Forrest
关注
专栏目录
C++入门基础(万字总结）（建议收藏！！！）
IamGreeHand的博客
09-22 26万+
文章目录什么是C++C++的发展史C++关键字命名空间命名空间的定义1.命名空间的普通定义2.命名空间可以嵌套3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。命名空间使用1.加命名空间名称及作用域限定符2.使用using namespace 命名空间名称引入3.使用using将命名空间中的成员引入C++中的输入和输出缺省参数全缺省半缺省参数函数重载函数重载的原理extern “C”引用引用的特征1.引用在定义时必须初始化2.一个变量可以有多个引用3.引用一旦引用了一个实体
C++ 7-2抽象基类Shape派生3个类(PTA题目)
vegitb_ciaken的博客
05-30 2724
声明抽象基类Shape,由它派生出三个类，圆形Circle，矩形Rectangle，三角形Triangle，用一个函数输出三个面积。 输入格式: 在一行中依次输入5个数，圆的半径，长方形的高和宽，三角形的高和底，中间用空格分隔 输出格式: 圆的面积，长方形的面积，三角形的面积，小数点后保留2位有效数字，每个面积占一行。 输入样例: 在这里给出一组输入。例如： 3 3 4 3 4 输出样例: 在这里给出相应的输出。例如： 28.27 12.00 6.00 参考答案： #include <iostre
Object类等
weixin_43504084的博客
02-22 284
Object类等 object 是java语言的根类，如果一个类没有父类，那么他的父类肯定就是object类。 object类当中包含的方法一共有11个，其实有两个方法特别重要分别是： toString（）； 返回该对象的字符串表示对象，其实该字符串的内容就是对象类型+@+内存地址。 由于toString方法返回的是内存地址，所以在开发中经常需要按照对象属性获得他的字符串，所以经常需要进行重写toString方法。 package com.rongyu.day09; /** * 重写toString方法
Python基础模块和类等
bit452的专栏
04-07 499
文章目录模块模块的概念模块的导入方式1）import 导入2）from...import 导入模块的搜索顺序__name__属性包（Package）包的概念案例演练`__init__.py` 模块 本文内容主要来自黑马Python教程B站 模块的概念 每一个以扩展名py结尾的Python源代码文件都是一个模块。 在模块中定义的全局变量 、函数、类都是提供给外界直接使用的工具。 模块名同样也是一个标识符，需要符合标识符的命名规则。 模块的导入方式 1）import 导入 提示：在导入模块时，每个导入应该独占
java 类相等_Java：什么是类型相等?
weixin_42566121的博客
02-19 285
看下面的例子：package com.zzj.classloader;import java.io.IOException;import java.io.InputStream;/*** 类型相等判断** @author Administrator**/public class ClassEqualTest {public static void main(String[] args) throw...
《C++程序设计原理与实践》笔记 第14章 设计图形类
zzy979481894的博客
03-06 754
本章借助图形接口类介绍接口设计的思想和继承的概念。为此，本章将介绍与面向对象程序设计直接相关的语言特性：类派生、虚函数和访问控制。
C++实验04(02)Shape类及其子类
多学习
05-02 3134
题目描述 定义一个基类Shape，有成员函数：calArea()，但什么都不做，返回0。在此基础上公有派生出Rectangle（矩形）类和Circle类，添加相应的数据成员（成员均为double型），重新定义calArea()计算对象的面积。 主函数中，分别定义一个Rectangle和Circle类对象，初始值由键盘输入。（1）通过对象调用相应的calArea()，输出结果；（2）定义Shape类...
C++基础知识总结
08-30
以下是C++基础知识总结，涵盖了new和malloc的区别、C++运算符、取地址运算符、引用、const变量等。 一、新和malloc的区别 在C++中，new和malloc都是用于申请内存的，但它们有着本质的区别。new和delete配对，释放...
少儿编程C++初级基础知识点.zip
10-23
【少儿编程C++初级基础知识点】是针对初学者设计的一系列C++编程教学内容，旨在帮助孩子们建立起坚实的编程基础。这个压缩包包含了多个章节的源代码文件，涵盖了C++语言的基础概念和关键语法，让我们逐一解析这些...
C++ 基础知识学习 C++ 基础知识.mk
02-24
C++的基础知识是所有C++程序员必须掌握的，这包括但不限于语法、变量、数据类型、运算符、控制结构、函数、类与对象、模板和异常处理。 1. **基本语法**：C++的语法基于C语言，但增加了许多面向对象的特性。它遵循...
用c++建立一个形状类Shape作为基类，派生出圆类Circle和矩形类Rectangle，求出面积并获取相关信息。
qq_36631131的博客
01-22 1万+
具体要求如下： （1）形状类Shape （a）保护数据成员 double x,y：对于不同的形状，x和y表示不同的含义，如对于圆，x和y均表示圆的半径，而对于矩形，x表示矩形的长，y表示矩形的宽。访问权限定义为保护类型是为了能被继承下去，以便派生类能直接访问x和y。 （b）公有成员函数 构造函数Shape(double _x,double _y)：用_x、_y分别初始化x、y。 dou
定义一个基类shape，实现正方形，矩形，圆类
热门推荐
secret
11-05 1万+
#include  using namespace std;   const float PI = (float)3.14159;   class Shape{ public:     virtual float CalCircumference()=0;     virtual float CalArea()=0; };   //
@图灵不吃苹果 #C++图形基类Shape 派生类Rectangle、Circle、Triangle类
我怎么这么菜啊7
09-13 3383
@图灵不吃苹果 C++图形基类和派生类的实现 实验要求 设计一个图形基类：Shape，在此基础上派生Rectangle、Circle、Triangle 类。 *1、Cirlce 类基本信息：圆心坐标、半径； Rectangle 类基本信息：长、宽； Triangle 类基本信息：三个顶点坐标； 其中：成员变量为 private 属性，成员函数为public 属性； 2、每个图形类有多个构造函数：缺省构造函数、带参数的构造函数； 3、每个图形类有计算图形的面积GetArea()，显示图形的基本信息函数Show
一道简单的C++笔试题，关于抽象shape类求图形周长的问题~
Y0uX1Nr3N的博客
03-21 2358
题目如下下列shape类是一个表示形状的抽象类，length()为求图形周长的函数，total()则是一个通用的用以求不同形状的图形周长总和的函数。请从shape类派生三角形类（striangle），矩形类（rectangle），并给出具体的求周长函数。给出shape，total的定义如下所示。class shape{public:virtual float length()=0};float t...
c++继承的简单问题，circle，rectangle继承shape
sinat_42721727的博客
07-29 2229
#define PI 3.14 #include&lt;iostream&gt; using namespace std; /*建立一个形状类Shape作为基类，派生出圆类Circle和矩形类Rectangle，求出面积并获取相关信息。具体要求如下： （1）形状类Shape （a）保护数据成员 double x,y：对于不同的形状，x和y表示不同的含义，如对于圆，x和y均表示圆的半径，而对于矩形...
pyqt瀑布流布局
weixin_54217201的博客
09-21 500
最近研究瀑布流布局，发现都是收费的，所以只能自己写算法写布局。所以啥都不说直接上代码。
189. 轮转数组（C++）
weixin_45813121的博客
09-25 441
给定一个整数数组nums，将数组中的元素向右轮转k个位置，其中k是非负数。
简易STL实现 | Set 的实现
最新发布
AsherGu的博客
09-26 432
如何使用；代码实现及其他（包括之前红黑树可以运行实现）
C++面向对象基础：类与封装
"这篇文档是关于C++基础知识中的类，主要介绍了面向对象的思想，包括抽象、封装和数据隐蔽等核心概念。" C++是一种强大的、支持面向对象编程（Object-Oriented Programming, OOP）的编程语言。面向对象的思想起源于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值