类的一些知识

最新推荐文章于 2024-07-24 08:30:00 发布

鸭仔不是鸭杂

最新推荐文章于 2024-07-24 08:30:00 发布

阅读量220

点赞数

文章标签： c++ c语言算法

本文链接：https://blog.csdn.net/yaya233666/article/details/126807347

版权

#一·类和结构体
##（一）类
###1.类的使用原则

类的使用方法
- 函数的体内和体外定义
- static的用法
  - 分类
    c++的类中静态变量分为静态成员变量和静态成员函数
  - 用处和特性
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bbTWkmKu-1662888623134)(2022-09-07-21-45-23.png)]
```
class test{
private:
    static int staticElem;
public
    static void func();
 }
int test::staticElem=10;//在类外给分配了
```
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1oEg134U-1662888623135)(2022-09-07-21-52-44.png)]
    注意，静态成员变量需要在类外分配内存空间，在类的内部声明，如下：
    注意，在关于使用静态成员来计数创建了多少变量时，需要注意覆盖每一个构造函数
    注意，静态成员变量的初始化是在类外进行，在实现中进行，避免多次初始化，前面无需加上static，　<数据类型><类名>::<静态数据成员名>=<值>
- 类模板
  - 模板的默认参数
  可以为类模板的类型形参提供默认值，但不能为函数模板的类型形参提供默认值。？？函数模板和类模板都可以为模板的非类型形参提供默认值;
  
  template<class T1,class T2=int> classA{};
  
  如果第一个定义了默认参数则后面都需要定义，类似于函数模板；
  
  template<class T1=int,class T2> classA{};//错误，因为后面也需要定义
  
  在类模板外定义函数的时候无需考虑默认值，就正常定于；
```
class A{
public:
    void func();
};
//下面是函数的定义：
 
template<class T1,class T2>
void A<T1,T2>::func()
{
    cout<<"hello world"<<endl;
}
```
  - 正常的类模板
    略；
  - 类模板在继承中的注意点
    - 如果子类非模板类，则必须要在继承中表明父类的类型，而且只要出现父类的地方就需要表明；
    - 如果子类是模板类，可以直接表明父类的类型，或者用自己的泛类型来表明父类的类型；
  - 类模板中的函数声明
    需要在前面加上模板声明和类声明，比较复杂麻烦
    注意，将函数的类外声明也是放在头文件中的！！！！！！！
```
class A{
public:
  void func();
};
//下面是函数的定义：

template<class T1,class T2>
void A<T1,T2>::func()
{
  cout<<"hello world"<<endl;
}
```
- const的用法（权限和匹配）
  - 对于变量的修饰
    如果是一般变量的话就是定义变量不可修改，但是如果定义在指针上需要注意：
    const char* p=new char[10];//含义为不可以通过指针来修改其指向的内容
    或者：
    char* const p=new char[10];//含义为不可以改变指针的指向
  - 对于函数的修饰
    - 当修饰形参时：
      指针的用法如前，对于传值的形参没有意义，对于引用修饰是使用原值但是不可以修改
    匹配：没有使用const的变量可以传入const函数中，特别是const &对于引用类型扩展是很重要的，可以接受非左值（表达式，字面常量），但是使用const的不能传入非const函数里面；
    - 当修饰返回值：
      修饰值的返回没有意义，const&的目的在于使返回值不会称为左值被修改：
```
int & min ( int &i, int &j)
{
    return i<j? i:j;
}
min ( a , b )=4;
//加上const就不会
```
    注意返回const&不可返回临时变量，最保险的做法是进来什么出来什么，而且这个用法不常见，最多用于类的赋值运算符重载来构成链式表达
```
 class A
{
   A &amp; operate = (const A &amp; other); // 赋值函数
   A a, b, c; // a, b, c 为A 的对象
   a = b = c; // 正常的链式赋值
   (a = b) = c; // 不正常的链式赋值，但合法
}
//如果将赋值函数的返回值加const 修饰，那么该返回值的内容不允许被改动。上例中，语句 a = b = c 仍然正确，但是语句 (a = b) = c 则是非法的。
```
    当修饰指针的时候，指针的内容不能被修改而且只能赋值给const同类型指针；
    - 类中的运用：
      - 对于成员函数加上const表明该函数不可以修改数据，const可以重载非const，类外定义也需要声明const.
      - 对于成员：
        [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3cvRJ60q-1662888623136)(2022-09-08-01-20-46.png)]
- 友元的用法
  - 关于意在类模板中不要滥用友元，除非重载运算符**
  - 三种opterator<<运算符号的重载
  - **注友元：全局函数友元，类友元，成员函数友元；
  - 友元模板有三种方式-非模板，约束模板，非约束模板；
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Q0WawEt8-1662888623136)(2022-09-11-15-13-58.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-k0a2zfcG-1662888623138)(2022-09-11-15-14-37.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-exZEB7LM-1662888623139)(2022-09-11-15-15-12.png)]
- 有关前置声明
当a和b类强耦合的时候，不能仅仅通过包含类来实现，需要使用到前置声明；
```
// A.h
#include "B.h"
class A
{
    B b;
public:
    A(void);
    virtual ~A(void);
};


//A.cpp
#include "A.h"
A::A(void)
{
}

A::~A(void)
{
}



// B.h
#include "A.h"
class B
{
    A a;
public:
    B(void);
    ~B(void);
};


// B.cpp
#include "B.h"
B::B(void)
{
}

B::~B(void)
{
}
//A中有B，B中有A，这是错误示范，编译器会被绕晕；
```
```
+ 前置声明： class A; //也就是告诉B是有A这样一个类存在，在编译的时候可以先通过然后再去找定义；
   + 前置声明的注意事项：==注意不可以如使用前置声明A的话只可以在头文件中使用其指针或引用的形式，不可以使用实例，也不可以调用其任何的方法或者成员，也不可以调用其析构函数（删除），因为这个class A大家都不知道到底有什么内容。==
```