（浅入浅出）小白学习c++工厂模式（入门搞懂版）

已于 2024-08-23 10:24:23 修改
阅读量1.2k 收藏 37
点赞数 25
分类专栏： 浅入浅出 文章标签： c++ 开发语言 笔记
于 2024-08-23 08:30:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45233816/article/details/141431727
版权

目录

1. 引入

2. 三种工厂模式

2.1 简单工厂模式

2.2 工厂方法模式

2.3 抽象工厂模式

3. 工厂模式的定义

参考资料

浅入浅出之小白学习软件设计方法之工厂模式！讲不明白算我输！

码字不易，如果觉得讲的好请不要吝啬你的一键三连！！！！！

本篇博客主要讲了软件设计方法之c++工厂模式。

声明，我也是小白，如果有错误，请指出，我们共同进步！

1. 引入

        我们先不看定义，请各位思考一个问题，我们刚入门c++的时候要创建一个对象该怎么创建？看下面伪代码。

class A {
public:
    xxxx
private:
    xxxx
};

class B {
public:
    xxxx
private:
    xxxx
};

int main() {
// 创建对象a
A a;

// 创建对象b
B b;
}

        现在是创建了两个类的对象，那如果有很多类呢？如果项目中需要创建很多对象呢？所以，工厂模式就提供了一种创建对象的方法。我的理解就是把创建对象的过程放到一个工厂类里面去，这个工厂类就相当于一个工厂一样，专门去产生（创建）一个个的产品（对象）。

2. 三种工厂模式

        我们还是不看定义，接下来我将采用UML类图加代码的形式讲述工厂模式的三种模式，分别是简单工厂模式、工厂方法模式、抽象工厂模式。

2.1 简单工厂模式

  • 场景：假如有一个制造车的工厂，要造SUV， 跑车，MPV三种车。
  • UML图如下所示

  •  根据UML图看如下代码
#include <iostream>

// 汽车抽象类
class Cars
{
public:
    virtual ~Cars() {} // 虚析构函数，确保正确调用派生类的析构函数
    virtual void cars_info() = 0; // 纯虚函数，要求派生类实现
};

// SUV汽车
class SUVCars : public Cars
{
public:
    void cars_info() override
    {
        std::cout << "我是SUV汽车，我的特点是：空间大，适合家庭出行" << std::endl;
    }
};

// 运动型汽车
class SportCars : public Cars
{
public:
    void cars_info() override
    {
        std::cout << "我是运动型汽车，我的特点是：速度快，外观时尚" << std::endl;
    }
};

// MPV汽车
class MPVCars : public Cars
{
public:
    void cars_info() override
    {
        std::cout << "我是MPV汽车，我的特点是：多功能，适合多人出行" << std::endl;
    }
};

// 简单工厂类
class CarsFactory
{
public:
    enum CarsType
    {
        SUV,
        SPORT,
        MPV
    };

    static Cars* create_cars(CarsType type)
    {
        switch (type)
        {
        case SUV:
            return new SUVCars();
        case SPORT:
            return new SportCars();
        case MPV:
            return new MPVCars();
        default:
            return nullptr;
        }
    }
};

int main()
{
    // 创建SUV汽车
    Cars* suv = CarsFactory::create_cars(CarsFactory::SUV);
    suv->cars_info();
    delete suv;

    // 创建运动型汽车
    Cars* sport = CarsFactory::create_cars(CarsFactory::SPORT);
    sport->cars_info();
    delete sport;

    // 创建MPV汽车
    Cars* mpv = CarsFactory::create_cars(CarsFactory::MPV);
    mpv->cars_info();
    delete mpv;

    return 0;
}

        是不是看的一头雾水，别慌我来为你逐个解释，首先既然工厂模式是用一个工厂类去创建其他的对象，我们肯定需要一个工厂类（Carsfactory），那么如何创建呢？我们只需要封装一个creat_cars函数，只要给这个函数一个参数，就可以根据这个参数创建不同的对象。

// 简单工厂类
class CarsFactory
{
public:
    enum CarsType
    {
        SUV,
        SPORT,
        MPV
    };

    static Cars* create_cars(CarsType type)
    {
        switch (type)
        {
        case SUV:
            return new SUVCars();
        case SPORT:
            return new SportCars();
        case MPV:
            return new MPVCars();
        default:
            return nullptr;
        }
    }
};

        那么既然创建对象，肯定要有相应的类，所以我们定义了SUVCars, SportCars, MPVCars。

// SUV汽车
class SUVCars : public Cars
{
public:
    void cars_info() override
    {
        std::cout << "我是SUV汽车，我的特点是：空间大，适合家庭出行" << std::endl;
    }
};

// 运动型汽车
class SportCars : public Cars
{
public:
    void cars_info() override
    {
        std::cout << "我是运动型汽车，我的特点是：速度快，外观时尚" << std::endl;
    }
};

// MPV汽车
class MPVCars : public Cars
{
public:
    void cars_info() override
    {
        std::cout << "我是MPV汽车，我的特点是：多功能，适合多人出行" << std::endl;
    }
};

         读到这里可能还有小白有疑问，那为什么还要继承抽象类(Cars)呢，直接通过工厂类(Carsfactory)创建对象不就好了，非也。

        这里之所以继承抽象类(Cars)，首先可以通过基类指针或引用来操作不同类型的派生类对象。在这个例子中，我们可以通过Cars*指针来调用cars_info方法，而不需要关心具体的汽车类型。这使得代码更加灵活和可扩展。

        基类Cars使得工厂类CarsFactory可以返回不同类型的汽车对象，而不需要知道具体的汽车类型。工厂类只需要返回基类指针，这使得工厂类的实现更加简洁和通用。

// 汽车抽象类
class Cars
{
public:
    virtual ~Cars() {} // 虚析构函数，确保正确调用派生类的析构函数
    virtual void cars_info() = 0; // 纯虚函数，要求派生类实现
};

        然后再看main函数，估计就会恍然大悟。

int main()
{
    // 创建SUV汽车
    Cars* suv = CarsFactory::create_cars(CarsFactory::SUV);
    suv->cars_info();
    delete suv;

    // 创建运动型汽车
    Cars* sport = CarsFactory::create_cars(CarsFactory::SPORT);
    sport->cars_info();
    delete sport;

    // 创建MPV汽车
    Cars* mpv = CarsFactory::create_cars(CarsFactory::MPV);
    mpv->cars_info();
    delete mpv;

    return 0;
}
  • 看懂了UML图和代码之后，我们来看简单工厂模式的结构组成

        抽象产品类： 定义了产品的接口，每个具体产品都要实现这个接口。例如，在我们的例子中，Cars 是抽象产品。

        具体产品类： 实现了抽象产品接口的具体类。例如，SUVCars、SportCars、MPVCars 是 Cars 的具体产品。

        工厂类： 核心类，包含一个方法，根据传入的参数决定创建哪种类型的对象。例如，CarsFactory 是工厂类，它声明了 create_cars 方法。

2.2 工厂方法模式

  • 简单工厂模式的问题：

        有了上面对简单工厂的理解，试想这样一种情景：当我们想要添加新的产品类，我们需要直接修改工厂类（CarsFactory），这显然违背了开闭原则（对扩展开放，对修改关闭）。那该怎么办？

        我们可以从工厂划分出子工厂，把创建对象的任务交给子工厂不就行了！直接看UML图和代码。

  • UML图如下所示

  • 根据UML图看如下代码
#include <iostream>

// 汽车抽象类
class Cars
{
public:
    virtual ~Cars() {} // 虚析构函数，确保正确调用派生类的析构函数
    virtual void cars_info() = 0; // 纯虚函数，要求派生类实现
};

// SUV汽车
class SUVCars : public Cars
{
public:
    void cars_info() override
    {
        std::cout << "我是SUV汽车，我的特点是：空间大，适合家庭出行" << std::endl;
    }
};

// 运动型汽车
class SportCars : public Cars
{
public:
    void cars_info() override
    {
        std::cout << "我是运动型汽车，我的特点是：速度快，外观时尚" << std::endl;
    }
};

// MPV汽车
class MPVCars : public Cars
{
public:
    void cars_info() override
    {
        std::cout << "我是MPV汽车，我的特点是：多功能，适合多人出行" << std::endl;
    }
};

// 抽象工厂类
class CarsFactory
{
public:
    virtual ~CarsFactory() {}
    virtual Cars* create_cars() = 0; // 纯虚函数，要求派生类实现
};

// SUV汽车工厂
class SUVCarsFactory : public CarsFactory
{
public:
    Cars* create_cars() override
    {
        return new SUVCars();
    }
};

// 运动型汽车工厂
class SportCarsFactory : public CarsFactory
{
public:
    Cars* create_cars() override
    {
        return new SportCars();
    }
};

// MPV汽车工厂
class MPVCarsFactory : public CarsFactory
{
public:
    Cars* create_cars() override
    {
        return new MPVCars();
    }
};

int main()
{
    // 创建SUV汽车
    CarsFactory* suvFactory = new SUVCarsFactory();
    Cars* suv = suvFactory->create_cars();
    suv->cars_info();
    delete suv;
    delete suvFactory;

    // 创建运动型汽车
    CarsFactory* sportFactory = new SportCarsFactory();
    Cars* sport = sportFactory->create_cars();
    sport->cars_info();
    delete sport;
    delete sportFactory;

    // 创建MPV汽车
    CarsFactory* mpvFactory = new MPVCarsFactory();
    Cars* mpv = mpvFactory->create_cars();
    mpv->cars_info();
    delete mpv;
    delete mpvFactory;

    return 0;
}

我想通过我上面的讲解，这里不用细讲，也能看懂了吧？总结一句话就是，具体产品对象的创建用具体的工厂子类完成。

  • 再看工厂方法模式的结构，一目了然

        抽象产品类： 定义了产品的接口，每个具体产品都要实现这个接口。例如，在我们的例子中，Cars 是抽象产品。

        具体产品类： 实现了抽象产品接口的具体类。例如，SUVCars、SportCars、MPVCars 是 Cars 的具体产品。

        抽象工厂类： 声明了一个创建产品的方法。例如，CarsFactory 是抽象工厂，它声明了 create_cars 方法。

        具体工厂类： 实现了抽象工厂接口，负责创建具体产品的实例。例如，SUVCarsFactory、SportCarsFactory、MPVCarsFactory 是具体工厂，它们实现了 create_cars 方法，分别创建相应的具体产品。

2.3 抽象工厂模式

        看懂了工厂方法模式，有时候这个工厂啊不仅仅生产一种产品，比如SUV工厂（SUVFactory），它除了产生SUV汽车产品（SUVCars），它有可能还需要生产SUV轮胎，SUV玻璃等等。这就是抽象工厂的内涵，话不多说，这次我相信直接看UML和代码就能看懂。

  • UML图如下所示

  • 根据UML图看代码（我建议直接从main函数开始看）
#include <iostream>

// 汽车抽象类
class Cars
{
public:
    virtual ~Cars() {} // 虚析构函数，确保正确调用派生类的析构函数
    virtual void cars_info() = 0; // 纯虚函数，要求派生类实现
};

// 轮胎抽象类
class Tires
{
public:
    virtual ~Tires() {}
    virtual void tire_info() = 0;
};

// SUV汽车
class SUVCars : public Cars
{
public:
    void cars_info() override
    {
        std::cout << "我是SUV汽车，我的特点是：空间大，适合家庭出行" << std::endl;
    }
};

// SUV轮胎
class SUVTires : public Tires
{
public:
    void tire_info() override
    {
        std::cout << "我是SUV轮胎，适合各种地形" << std::endl;
    }
};

// 运动型汽车
class SportCars : public Cars
{
public:
    void cars_info() override
    {
        std::cout << "我是运动型汽车，我的特点是：速度快，外观时尚" << std::endl;
    }
};

// 运动型轮胎
class SportTires : public Tires
{
public:
    void tire_info() override
    {
        std::cout << "我是运动型轮胎，适合高速行驶" << std::endl;
    }
};

// MPV汽车
class MPVCars : public Cars
{
public:
    void cars_info() override
    {
        std::cout << "我是MPV汽车，我的特点是：多功能，适合多人出行" << std::endl;
    }
};

// MPV轮胎
class MPVTires : public Tires
{
public:
    void tire_info() override
    {
        std::cout << "我是MPV轮胎，适合长途旅行" << std::endl;
    }
};

// 抽象工厂类
class CarsFactory
{
public:
    virtual ~CarsFactory() {}
    virtual Cars* create_cars() = 0; // 纯虚函数，要求派生类实现
    virtual Tires* create_tires() = 0; // 纯虚函数，要求派生类实现
};

// SUV工厂
class SUVCarsFactory : public CarsFactory
{
public:
    Cars* create_cars() override
    {
        return new SUVCars();
    }

    Tires* create_tires() override
    {
        return new SUVTires();
    }
};

// 运动型汽车工厂
class SportCarsFactory : public CarsFactory
{
public:
    Cars* create_cars() override
    {
        return new SportCars();
    }

    Tires* create_tires() override
    {
        return new SportTires();
    }
};

// MPV工厂
class MPVCarsFactory : public CarsFactory
{
public:
    Cars* create_cars() override
    {
        return new MPVCars();
    }

    Tires* create_tires() override
    {
        return new MPVTires();
    }
};

int main()
{
    // 创建SUV汽车和轮胎
    CarsFactory* suvFactory = new SUVCarsFactory();
    Cars* suv = suvFactory->create_cars();
    Tires* suvTires = suvFactory->create_tires();
    suv->cars_info();
    suvTires->tire_info();
    delete suv;
    delete suvTires;
    delete suvFactory;

    // 创建运动型汽车和轮胎
    CarsFactory* sportFactory = new SportCarsFactory();
    Cars* sport = sportFactory->create_cars();
    Tires* sportTires = sportFactory->create_tires();
    sport->cars_info();
    sportTires->tire_info();
    delete sport;
    delete sportTires;
    delete sportFactory;

    // 创建MPV汽车和轮胎
    CarsFactory* mpvFactory = new MPVCarsFactory();
    Cars* mpv = mpvFactory->create_cars();
    Tires* mpvTires = mpvFactory->create_tires();
    mpv->cars_info();
    mpvTires->tire_info();
    delete mpv;
    delete mpvTires;
    delete mpvFactory;

    return 0;
}

        是不是看到这么宽的UML图，和这么长的代码就感觉不好理解。有什么不好理解的，直接看main函数，你会发现其实SUV工厂（SUVFactory）造SUV车产品（SUVCars）和SUV轮胎产品（SUVTires）

        总结就是一个具体工厂类，可以造多个同系列的产品。

        还难吗？？

  • 抽象工厂模式的结构

        抽象产品类：定义了产品的接口，每个具体产品都要实现这个接口。例如，在我们的例子中，Cars 和 Tires 是抽象产品。

        具体产品类：实现了抽象产品接口的具体类。例如，SUVCars、SportCars、MPVCars 是 Cars 的具体产品，SUVTires、SportTires、MPVTires 是 Tires 的具体产品

        抽象工厂类：声明了一组创建产品的方法，每个方法对应一个抽象产品。例如，CarsFactory 是抽象工厂，它声明了 create_cars 和 create_tires 方法。

        具体工厂类：实现了抽象工厂接口，负责创建具体产品的实例。例如，SUVCarsFactory、SportCarsFactory、MPVCarsFactory 是具体工厂，它们实现了 create_cars 和 create_tires 方法，分别创建相应的具体产品。

3. 工厂模式的定义

        有了上面的讲解，我们现在看工厂模式的定义，是不是就很清楚了。

        工厂模式（Factory Pattern）是一种创建型设计模式，它提供了一种创建对象的方式，使得创建对象的过程与使用对象的过程分离。工厂模式的主要目的是将对象的创建过程封装在工厂类中，客户端代码只需要关心从工厂获取对象的过程，而不需要了解对象的创建细节。

参考资料

C++之工厂模式
flyingcloud6的博客
06-23 4946
对于工厂模式（简单工厂、工厂方法、抽象工厂）的总结。
C++之工厂(factory)模式
热门推荐
lovely_yoshino的博客
03-07 1万+
0. 简介 继单例模式写完后，我觉得对于C++的高级用法可以来开一个专栏来专门整理与阐述，这里，我将以我们最常用的工厂模式开始，来逐步的共同学习。 https://www.cnblogs.com/hebaichuanyeah/category/824625.html ......
C++ 设计模式——工厂模式
最新发布
qq_68194402的博客
08-17 1761
工厂模式是一种创建对象的设计模式，主要用于将对象的创建与使用分离。它提供了一种接口来创建对象，但由子类决定实例化哪个类。工厂模式有几种变体，包括简单工厂模式、工厂方法模式和抽象工厂模式。
C++工厂模式
zt18786458319的博客
11-16 2796
条件：将该类的构造函数私有化，目的是禁止其他程序创建该类的对象，同时也是为了提醒查看代码的人我这里是在使用单例模式，防止他人将这里任意修改。指向自己实例的私有引用在被类方法(creatinstance)调用时被初始化，只有静态成员变量才能在没有创建对象时进行初始化，并且类的静态成员在第一次使用时不会再被初始化，保证了单例，因此设置为静态。通过类方法（creatinstance) 获取instance，类属性instance为静态的(static)，则需要类的静态方法才能调用，因此该类方法应设为静态的。
设计模式之工厂模式(C++)
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
08-03 1894
设计模式之工厂模式的学习了解
【C++】—— 工厂模式详解
m0_56069910的博客
01-09 2762
工厂模式详解（包含简单工厂模式，工厂方法模式，抽象工厂模式）
如何系统的学习c++
m0_37940804的博客
05-08 4602
大家好，我是羽峰，一个c++刚入门的小白，本文整理了一些c++学习路线，当然自己也在路上，期待与您一起成长。如有需要，欢迎关注“羽峰码字”公众号，我们一起畅聊人生。 学习C++ 可以分为几个阶段 1. 入门 1.1C语言基础 首先是c语言基础 基础的语法：变量、条件、循环、字符串、数组、函数、结构体等 C语言重点：指针、内存管理 推荐书籍：《C Primer Plus》、《C和指针》、《C专家编程》 当然这只是c++基础，理解就好，当然，指针和内存管理是很重要的，建议多理解，多看看...
经验分享：C++程序员从小白到大神的成长之路
pangzizzzz的博客
07-20 1485
序言 C++是一门略微比其他语言难一点的语言，它更偏向于底层，而且它包含的思想比较多，如果你只学习语言本身，不关注它所涉及的思想，将会在未来的实际应用中举步维艰，所以学习该门语言需要你付出双倍的精力来学习它的附属知识。 学习编程语言后你要做哪些 编程语言本身的思想都是贯通的，无论你学习C/C++，JAVA还是PHP,Object_C,Python。他们都是一种思想，当你学会其中一门去学其他的就会变得相对容易。 学会一门语言后可以去做这些事情，你主要找一个方向努力即可： 传统开发（如开发各种管理系统） 移动
C语言与C++学习路线
qq_43351159的博客
06-15 255
有人说：“C生万物，编程之本”，这一点都没有错！ C语言是最接近计算机的语言，很多时间，我们都会发现，C语言是非常有必要学习的。 C语言 数据类型、变量、内存布局、指针基础； 字符串、一维数组、二维数组； 一级指针，二级指针，三级指针，N级指针概念，指针数组和数组指针； 结构体、文件的使用； 动态库的封装和设计； 函数指针回调函数。 配套视频： 轻松掌握C语言视频教程（会打字就能学会） 全国计算机等级考试二级c语言视频教61节课 浙大翁恺C语言入门 C语言提高深入浅出 七日成蝶之C语言数据结构经典合集高级视
C++后台开发学习路线（已多人拿下腾讯后台开发）
Linuxhus的博客
09-03 2421
首先介绍下自己吧，本人系统架构师，曾供职著名创业公司系统架构师，微软亚洲研究院、创维集团。著有多个软件专利，参与多个开源软件维护。ntytcp,ntyco的founder，github follow人数1.4k。
校招｜ C++ 后台开发学习路线
C语言与CPP编程的博客
03-09 1546
一直有一些读者来问我要学习经验。我也很想写一个学习路线给大家，希望可以帮助到更多的小伙伴少走弯路。之前一直没写的原因在于自己觉得自己懂得太少，还没成为一个大佬，还没成为一个精通某个领域的...
【C++】设计模式：工厂模式
DevFrank的博客
03-25 1297
设计模式：工厂模式
C++设计模式(工厂模式)
m0_49476241的博客
08-24 2003
本篇文章正式带大家来学习C++中的设计模式，这篇文章主要带大家学习工厂模式。工厂模式（Factory Pattern）是一种创建型设计模式，它提供了一种创建对象的接口，但将具体对象的实例化延迟到子类或具体工厂类中。工厂模式通过解耦客户端代码和创建具体对象的过程，使客户端代码不需要直接依赖于具体对象的创建方式，而是通过工厂来创建对象，从而提高代码的灵活性和可维护性。在C++中，工厂模式可以有多种实现方式，包括简单工厂模式、工厂方法模式和抽象工厂模式。本篇文章就讲解到这里。
c++ 工厂模式
weixin_45672157的博客
06-18 1704
工厂模式（FactoryPattern）是设计模式中的一种，属于创建型模式。它的核心思想是为了解耦对象的创建过程与使用过程，让代码更加灵活，易于扩展和维护。工厂模式通过引入一个工厂类来负责对象的创建，而客户端代码只需要与这个工厂类交互，无须关心具体的对象创建细节。封装性：隐藏了对象创建的具体逻辑，客户端代码不需要知道对象是如何被创建出来的。开放封闭原则：当需要添加新的产品时，只需要增加一个新的具体产品类和修改工厂类（或新增一个工厂子类），不需要修改现有代码，符合软件设计的开放封闭原则。
C++设计模式（工厂模式）
qq_55882840的博客
05-19 1620
简单工厂模式工厂方法模式和抽象工厂模式。工厂模式的作用是生产对象，可以简化代码、提高可维护性，并旦可以通过工厂类生产多种对象。简单工厂模式适用于创建简单的对象，工厂模式适用于创建复杂的对象，而抽象工厂模式适用于创建更复杂的对象。
C++创建型模式-工厂模式
灰太狼的小秘密
08-26 1万+
一、基础知识 1.1 简单工厂模式 简单工厂模式（Simple Factory Pattern）专门定义一个类来负责创建其他类的实例，被创建的实例通常具有共同的父类。 1.2 简单工厂模式的角色 二、C++实现工厂模式 参考文献： 【1】 ......
C++设计模式 - 创建型模式之工厂模式
kakaka666的博客
06-11 1781
工厂模式最直观的理解是，减少new创建对象的方式，用接口的方式来返回一个对象，而new创建的方式被封装了简单工厂：调用者只需使用单例工厂就可获取同一范畴的所有产品工厂方法：调用者并不知道它在运行时会获取何种产品，只知道某个特定的工厂能生成出满足需求的产品抽象工厂：调用者可以在运行时从特定的工厂中获得所有信息相关的产品簇(可以对产品进行组合)
C++设计模式-工厂模式
IT1995的博客
06-13 6726
目录 基本概念 代码及实例 基本概念 工厂方法模式（Factory Method）：定义一个用于创建对象的接口，让字类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类； 简单工厂模式的最大优点在用户工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了具体产品的依赖。 工厂方法模式实现时，客户端需要决定实例化哪一个工厂来实...
C++ 设计模式——抽象工厂模式
qq_68194402的博客
08-17 1404
抽象工厂模式提供一个接口，用于创建一系列相关或相互依赖的对象，而无需指定它们的具体类。它通常用于需要创建多个产品族的场景。
《深入浅出MFC》第二版高清电子书
"深入浅出MFC第二版高清.pdf" 《深入浅出MFC》第二版是一本关于Microsoft Foundation Classes (MFC) 框架的深入解析书籍，由知名作者侯捷撰写。这本书旨在帮助读者理解和掌握MFC编程，特别适合有一定C++基础和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值