C++之多层 if-else-if 结构优化(二)

已于 2024-02-02 12:53:26 修改
阅读量911 收藏 11
点赞数 17
分类专栏： #编程技巧 文章标签： c++ 开发语言 设计模式
于 2023-12-21 10:29:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/haokan123456789/article/details/135122930
版权

相关系列文章

C++之多层 if-else-if 结构优化(一)

C++之多层 if-else-if 结构优化(二)

C++之多层 if-else-if 结构优化(三)

设计模式之责任链模式

设计模式之工厂模式

设计模式之策略模式

目录

7.使用责任链模式进行结构优化

8.利用模板元编程的萃取原理来优化

9.利用策略模式+工厂模式来优化

7.使用责任链模式进行结构优化

        责任链模式，Chain of responsibility，是GoF中的behavior pattern行为模式中的一种，在所有的行为模式中，设计的准则都为：使用对象的组合而不是对象的继承。责任链模式所描述的是：与其从已有的类中继承新的类，不如让你的类指向一个你要使用的已经存在的类。该模式用于解耦发送请求的客户与处理请求的对象，实现方式为持有一系列的handler对象，每个对象都能处理特定的请求，如果某个handler不能处理该请求，它将请求传递给链中的下一个对象。在链的末端，会有一个或多个通用的（generic）handler，用于对请求的默认处理。

　　该模式为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。

        责任链模式的重点是在“链”上，由一条链去处理相似的请求在链中决定谁来处理这个请
求，并返回相应的结果，其通用类图如下图所示。

根据责任链模式，设计类图如下：

代码如下：

#define  MAX_PARAM   0x7FFFFFFF
class IMessageEntityBase
{
public:
	virtual int  func(int num) = 0;
};

class CMessageEntity1 : public IMessageEntityBase
{
public:
	explicit CMessageEntity1(IMessageEntityBase* pNext) : m_pNext(pNext) {}
	int  func(int num) override {
		if (num < 0) {
			qDebug() << "类CMessageEntity1 调用函数 -- func() " << "   传递参数: num: " << num;
			return num;
		}
		return m_pNext ? m_pNext->func(num) : MAX_PARAM;
	}
private:
	IMessageEntityBase* m_pNext;
};

class CMessageEntity2 : public IMessageEntityBase
{
public:
	explicit CMessageEntity2(IMessageEntityBase* pNext) : m_pNext(pNext) {}
	int  func(int num) override {
		if (num > 0 && num <= 10) {
			qDebug() << "类CMessageEntity2 调用函数 -- func() " << "   传递参数: num: " << num;
			return num;
		}
		return m_pNext ? m_pNext->func(num) : MAX_PARAM;
	}
private:
	IMessageEntityBase* m_pNext;
};

class CMessageEntity3 : public IMessageEntityBase
{
public:
	explicit CMessageEntity3(IMessageEntityBase* pNext) : m_pNext(pNext) {}
	int  func(int num) override {
		if (num > 10 && num <= 100) {
			qDebug() << "类CMessageEntity3 调用函数 -- func() " << "   传递参数: num: " << num;
			return num;
		}
		return m_pNext ? m_pNext->func(num) : MAX_PARAM;
	}
private:
	IMessageEntityBase* m_pNext;
};

class CMessageEntity4 : public IMessageEntityBase
{
public:
	explicit CMessageEntity4(IMessageEntityBase* pNext) : m_pNext(pNext) {}
	int  func(int num) override {
		if (num > 100 && num <= 1000) {
			qDebug() << "类CMessageEntity4 调用函数 -- func() " << "   传递参数: num: " << num;
			return num;
		}
		return m_pNext ? m_pNext->func(num) : MAX_PARAM;
	}
private:
	IMessageEntityBase* m_pNext;
};

class CMessageEntity5 : public IMessageEntityBase
{
public:
	explicit CMessageEntity5(IMessageEntityBase* pNext) : m_pNext(pNext) {}
	int  func(int num) override {
		if (num > 1000 && num <= 10000) {
			qDebug() << "类CMessageEntity5 调用函数 -- func() " << "   传递参数: num: " << num;
			return num;
		}
		return m_pNext ? m_pNext->func(num) : MAX_PARAM;
	}
private:
	IMessageEntityBase* m_pNext;
};

class CMessageEntityOverRange : public IMessageEntityBase
{
public:
	explicit CMessageEntityOverRange(IMessageEntityBase* pNext) : m_pNext(pNext) {}
	int  func(int num) override {
		if (num >= 10000) {
			qDebug() << "类CMessageEntityOverRange 调用函数 -- func() " << "   传递参数: num: " << num;
			return num;
		}
		return m_pNext ? m_pNext->func(num) : MAX_PARAM;
	}
private:
	IMessageEntityBase* m_pNext;
};

class CTestMessageEntity
{
public:
	void setFunctor(IMessageEntityBase* pFunctor) {
		m_functor = pFunctor;
	}
	int func(int num)
	{
		return m_functor->func(num);
	}
private:
	IMessageEntityBase* m_functor;
};

int  main()
{
	std::unique_ptr<IMessageEntityBase> pOverRanage(new CMessageEntityOverRange(nullptr));
	std::unique_ptr<IMessageEntityBase> pFunctor5(new CMessageEntityOverRange(pOverRanage.get()));
	std::unique_ptr<IMessageEntityBase> pFunctor4(new CMessageEntityOverRange(pFunctor5.get()));
	std::unique_ptr<IMessageEntityBase> pFunctor3(new CMessageEntityOverRange(pFunctor4.get()));
	std::unique_ptr<IMessageEntityBase> pFunctor2(new CMessageEntityOverRange(pFunctor3.get()));
	std::unique_ptr<IMessageEntityBase> pFunctor1(new CMessageEntityOverRange(pFunctor2.get()));

	CTestMessageEntity  test;
	test.setFunctor(pFunctor1.get());

	int result = test.func(5);
	result = test.func(80);
	result = test.func(1500);
	result = test.func(8000);

	return 0;
}

8.利用模板元编程的萃取原理来优化

        萃取的实现方法：模板偏特化后使用using对偏特化的参数取别名；使用static成员；使用参数化萃取。

        萃取的目的是实现 标签派发。

        在我的博客 std::apply源码分析-CSDN博客 的 std::__invoke 实现部分也用到了类型萃取技术，可以去看看。

先看一下没有优化之前的代码：

MessageField.h

template <messageType TYPE, typename T, typename = std::enable_if_t<std::is_same<T,std::uint32_t>::value||
                                                                   std::is_same<T,std::int32_t>::value ||
                                                                   std::is_same<T,double>::value ||
                                                                   std::is_same<T,std::uint64_t>::value ||
                                                                   std::is_same<T,std::uint16_t>::value ||
                                                                   std::is_same<T,float>::value>>
class CMessageStringTField : public CMessageStringField
{
    using _base = CMessageStringField;

public:
    explicit CMessageStringTField(){ }
    CMessageStringTField(const CMessageStringTField& other)
        : _base(other){
    }
    virtual ~CMessageStringTField(){}

public:
    IMessageField* clone(const IMessageField* pSrc) const override{
        return new CMessageStringTField(*dynamic_cast<const CMessageStringTField*>(pSrc));
    }
    messageType type() const override{
        return TYPE;
    }
    bool isMultiValue() const override{
        return true;
    }
    //和客户端交互的接口,kv一对一和一对多类型
    bool getPacketValue(std::vector<std::uint64_t>& values) const override{
        std::vector<T> data;
        //[1] 将string转为T
        if constexpr(std::is_same<T, std::uint64_t>::value){
            gSplitString<T>(m_value, ::atoll, data);
        }else if constexpr(std::is_same<T, std::uint32_t>::value){
            gSplitString<T>(m_value, ::atol, data);
        }else if constexpr(std::is_same<T, std::uint16_t>::value){
            gSplitString<T>(m_value, ::atol, data);
        }else if constexpr(std::is_same<T, std::int32_t>::value){
            gSplitString<T>(m_value, ::atoi, data);
        }else if constexpr(std::is_same<T, float>::value){
            gSplitString<T>(m_value, ::atof, data);
        }else if constexpr(std::is_same<T, double>::value){
            gSplitString<T>(m_value, ::atof, data);
        }else{
            assert(0);
        }

        //[2] 将T转为std::uint64_t
        for(auto& it : data){
            values.push_back(transTToPUInt64(it));
        }
        return true;
    }
    //kv一对多类型
    bool setPacketValue(const std::vector<std::uint64_t>& values) override{
        m_value.clear();
        for (int i = 0; i < values.size(); i++){
            m_value += numConvertString(transPUInt64ToT<T>(values[i]));
            if (i != values.size()-1){
                m_value += ",";
            }
        }
        return true;
    }
    ...
};

        里面的if constexpr(...) 表达式，编译器在编译时期使用编译时期表达式决定是否使用if语句或then部分或else部分(如果有的话)。如果其中一个分支条件成立，则另一部分(如果有的话)被丢弃，这样也就不会生成被丢弃部分的代码。但是，这并不意味着被丢弃的部分完全被忽略，它就像未使用模板的代码一样检查语法等。

        gSplitString的实现如下：

template <typename T, typename FUNC = T(const char*),
         typename = std::enable_if_t<std::is_arithmetic<T>::value>>
void gSplitString(const std::string& data, FUNC&& func, std::vector<T>& vecValue)
{
    const char * split = ",";
    std::unique_ptr<char[]> temp(new char[data.size()+1]);
    memcpy(temp.get(), data.c_str(), data.size());
    temp[data.size()] = '\0';

    // 以逗号为分隔符拆分字符串
    char *p = strtok(temp.get(), split);

    while(p != NULL)
    {
        vecValue.push_back((T)func(p));
        p = strtok(NULL, split);
    }
}

在类成员函数getPacketValue中根据T的类型，调用不同的转换函数进行处理，基本都是字符串向数值类型转换，比较多的if constexpr 使得代码比较难看，扩展性也不好；那有没有什么办法根据T就是直接推导出使用那个转换函数呢，于是类型萃取技术就是粉墨登场了，其实类型萃取技术也不是什么高深的技术，在STL中很多地方都用到了类型萃取技术，如：迭代器iterator中iterator_category， 通过它可以提取到的类型有五种，如下：

  • input iterator：只读
  • output iterator：只写
  • forward iterator：允许写入，在此迭代器所形成的区间上进行读写操作
  • bidirectional iterator：可以双向移动
  • random access iterator：支持指针的所有算数操作

然后STL的算法模块就根据 iterator_category 的不同调用不同的算法函数。

上面的代码我们也是根据这个原理来优化，优化后的代码如下：

MessageStringTFieldAssist.h

namespace xyLinkCorePrivate {
    struct _tag_int64_value {};
    struct _tag_uint32_value {};
    struct _tag_int32_value {};
    struct _tag_double_value {};

    template <typename T>
    void _splitString(_tag_int64_value, const std::string& value, std::vector<T>& data){
        gSplitString<T>(value, ::atoll, data);
    }
    template <typename T>
    void _splitString(_tag_uint32_value, const std::string& value, std::vector<T>& data){
        gSplitString<T>(value, ::atol, data);
    }
    template <typename T>
    void _splitString(_tag_int32_value, const std::string& value, std::vector<T>& data){
        gSplitString<T>(value, ::atoi, data);
    }
    template <typename T>
    void _splitString(_tag_double_value, const std::string& value, std::vector<T>& data){
        gSplitString<T>(value, ::atof, data);
    }

    #define  IS_INT64_VALUE(T)             (std::is_same<T,std::uint64_t>::value||std::is_same<T,std::int64_t>::value)
    #define  IS_SIGNED_LESS32_VALUE(T)     (std::is_same<T,std::uint32_t>::value||std::is_same<T,std::uint16_t>::value)
    #define  IS_UNSIGNED_LESS32_VALUE(T)   (std::is_same<T,std::int32_t>::value||std::is_same<T,std::int16_t>::value)

    template <typename T>
    struct _value_type_category{
        //typename千万不能省略，2023.12.14调试了大半天都没有搞明白是咋回事，一直编译报错
        using type = typename std::conditional<IS_INT64_VALUE(T), _tag_int64_value,
                                               typename std::conditional<IS_SIGNED_LESS32_VALUE(T), _tag_uint32_value,
                                                                         typename std::conditional<IS_UNSIGNED_LESS32_VALUE(T), _tag_int32_value, _tag_double_value>::type>::type>::type;
    };

    #undef  IS_INT64_VALUE
    #undef  IS_SIGNED_LESS32_VALUE
    #undef  IS_UNSIGNED_LESS32_VALUE
}

MessageField.h

#define IS_SUIT_TYPE(T)  (  std::is_same<T,std::uint32_t>::value||    \
                            std::is_same<T,std::int32_t>::value ||    \
                            std::is_same<T,double>::value ||          \
                            std::is_same<T,std::uint64_t>::value ||   \
                            std::is_same<T,std::uint16_t>::value ||   \
                            std::is_same<T,float>::value )

template <messageType TYPE, typename T, typename = std::enable_if_t<IS_SUIT_TYPE(T)>>
//template <messageType TYPE, typename T, std::enable_if_t<IS_SUIT_TYPE(T),int> = 0>
class CMessageStringTField : public CMessageStringField
{
    using _base = CMessageStringField;

public:
    explicit CMessageStringTField(){ }
    CMessageStringTField(const CMessageStringTField& other)
        : _base(other){
    }
    virtual ~CMessageStringTField(){}

public:
    IMessageField* clone(const IMessageField* pSrc) const override{
        return new CMessageStringTField(*dynamic_cast<const CMessageStringTField*>(pSrc));
    }
    messageType type() const override{
        return TYPE;
    }
    bool isMultiValue() const override{
        return true;
    }

public:
    //和客户端交互的接口,kv一对一和一对多类型
    bool getPacketValue(std::vector<std::uint64_t>& values) const override{
        static_assert(IS_SUIT_TYPE(T),"T is not std::uint32_t or std::int32_t or float or double or std::uint16_t or std::uint64_t");
        std::vector<T> data;
        //[1] 将string转为T
        using t = typename xyLinkCorePrivate::_value_type_category<T>::type;
        xyLinkCorePrivate::_splitString(t{}, m_value, data);

        //[2] 将T转为std::uint64_t
        for(auto& it : data){
            values.push_back(transTToPUInt64(it));
        }
        return true;
    }
    //kv一对多类型
    bool setPacketValue(const std::vector<std::uint64_t>& values) override{
        m_value.clear();
        for (int i = 0; i < values.size(); i++){
            m_value += numConvertString(transPUInt64ToT<T>(values[i]));
            if (i != values.size()-1){
                m_value += ",";
            }
        }
        return true;
    }
    ...
};

优化代码后，函数getPacketValue的逻辑就比较清晰明了，通俗易懂。

9.利用策略模式+工厂模式来优化

        根据传入参数num的不同，调用不用的处理方法。那么就可以把这个处理流程分成两条线，一条线是处理方法，可以称之为处理策略，另外一条是根据num的不同，生成不同的处理策略，根据我们之前讲解的工厂模式，是不是有点像简单工厂的味道？实际上也是。

        首先，我们把每个条件逻辑代码块，抽象成一个公共的接口，可以得出以下代码：

//抽象策略接口
class IMessageEntityBase
{
public:
	virtual int  func() = 0;
};
//具体策略1
class CMessageEntity1 : public IMessageEntityBase
{
public:
	explicit CMessageEntity1(int num) : m_num(num) {}
	int  func() override {
		qDebug() << "类CMessageEntity1 调用函数 -- func() " << "   传递参数: num: " << m_num;
		return m_num;
	}
private:
	int m_num;
};
//具体策略2
class CMessageEntity2 : public IMessageEntityBase
{
public:
	explicit CMessageEntity2(int num) : m_num(num) {}
	int  func() override {
		qDebug() << "类CMessageEntity2 调用函数 -- func() " << "   传递参数: num: " << m_num;
		return m_num;
	}
private:
	int m_num;
};
//具体策略3
class CMessageEntity3 : public IMessageEntityBase
{
public:
	explicit CMessageEntity3(int num) : m_num(num) {}
	int  func() override {
		qDebug() << "类CMessageEntity3 调用函数 -- func() " << "   传递参数: num: " << m_num;
		return m_num;
	}
private:
	int m_num;
};
//具体策略4
class CMessageEntity4 : public IMessageEntityBase
{
public:
	explicit CMessageEntity4(int num) : m_num(num) {}
	int  func() override {
		qDebug() << "类CMessageEntity4 调用函数 -- func() " << "   传递参数: num: " << m_num;
		return m_num;
	}
private:
	int m_num;
};
//具体策略5
class CMessageEntity5 : public IMessageEntityBase
{
public:
	explicit CMessageEntity5(int num) : m_num(num) {}
	int  func() override {
		qDebug() << "类CMessageEntity5 调用函数 -- func() " << "   传递参数: num: " << m_num;
		return m_num;
	}
private:
	int m_num;
};
//具体策略6
class CMessageEntityOverRange : public IMessageEntityBase
{
public:
	explicit CMessageEntityOverRange(int num) : m_num(num) {}
	int  func() override {
		assert(0);
		qDebug() << "类CMessageEntityOverRange 调用函数 -- func() " << "   传递参数: num: " << m_num;
		return -1;
	}
private:
	int m_num;
};

接下来，我们再定义策略工厂类，用来管理具体策略类，如下：

//策略工厂
class CMessageEntityFactory
{
	using R = std::shared_ptr<IMessageEntityBase>;
	using FUNC = std::function<R(int)>;
public:
	explicit CMessageEntityFactory() {
		m_vecFactory.emplace_back([](int num)->R {
			R pMessageEntiry;
			if (num <= 0) {
				pMessageEntiry.reset(new CMessageEntity1(num));
			}
			return pMessageEntiry;
			});
		m_vecFactory.emplace_back([](int num)->R {
			R pMessageEntiry;
			if (num > 0 && num <= 10) {
				pMessageEntiry.reset(new CMessageEntity2(num));
			}
			return pMessageEntiry;
			});
		m_vecFactory.emplace_back([](int num)->R {
			R pMessageEntiry;
			if (num > 10 && num <= 100) {
				pMessageEntiry.reset(new CMessageEntity3(num));
			}
			return pMessageEntiry;
			});
		m_vecFactory.emplace_back([](int num)->R {
			R pMessageEntiry;
			if (num > 100 && num <= 1000) {
				pMessageEntiry.reset(new CMessageEntity4(num));
			}
			return pMessageEntiry;
			});
		m_vecFactory.emplace_back([](int num)->R {
			R pMessageEntiry;
			if (num > 1000 && num <= 10000) {
				pMessageEntiry.reset(new CMessageEntity5(num));
			}
			return pMessageEntiry;
			});
		m_vecFactory.emplace_back([](int num)->R {
			R pMessageEntiry;
			if (num > 10000) {
				pMessageEntiry.reset(new CMessageEntityOverRange(num));
			}
			return pMessageEntiry;
			});
	}
	R create(int num) {
		R temp;
		for (int i = 0; i < m_vecFactory.size(); i++) {
			if (temp = m_vecFactory[i](num)) {
				break;
			}
		}
		return temp;
	}
private:
	std::vector<FUNC> m_vecFactory;
};

使用了策略+工厂模式之后，代码变得简洁多了，如下：

int  main()
{
	CMessageEntityFactory  factory;
	auto pFunctor = factory.create(5);
	auto result = pFunctor->func();

	pFunctor = factory.create(80);
	result = pFunctor->func();

	pFunctor = factory.create(1500);
	result = pFunctor->func();

	pFunctor = factory.create(8000);
	result = pFunctor->func();

	return 0;
}

C++之多层 if-else-if 结构优化(三)-CSDN博客

流星雨爱编程
关注
  • 17
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++ 分支结构--if-else
02-19
平时我们在说“如果……那么……”的时候，还经常和“否则……”连用。比如：如果明天天气好，就开运动会，否则就不开。按照之前的内容，我们只能这样说：如果明天天气好，就开运动会；如果明天天气不好，就不开运动...
c++if和else，5-2！
06-11
c++if和else，5-2！
C++ - if 、else、else_if 语句
A140101的博客
04-28 1401
C++ - if 、else、else_if 语句
C++程序基础（7）：if与else语句
2301_78806067的博客
07-04 1869
C++程序基础（7）：if与else语句
业务逻辑中针对if ---else或者 else if 等多层嵌套常用优化实现方法总结
最新发布
lianxiwang2008的专栏
03-21 832
业务逻辑中针对if ---else或者 else if 等多层嵌套常用优化实现方法；查找表（Lookup Table）； 函数指针数组； 状态机； 策略模式。
一文读懂C++的if与else判断语句
Eric-lsl的博客
03-14 5928
说个明白 先从最简单的说起。 if语句 if语句是C++中最简单的判断语句。 if(S) // 语句1 // 语句2 如果S为真（非零），则执行语句1，否则执行语句2。 如果语句1就是单个语句，则可以这么写： if(S) 语句1; // 这里的分号不能少 或者这么写： if(S){ 语句1; } 如果语句1是个复合语句，则应该这么写: if(S){ 语句1; ...
C++ if, if...else和嵌套if...else
GZXGYZ的博客
11-16 659
如果测试表达式（test Expression）为true，则if...else在if语句的主体内执行代码，并跳过else主体内部的代码。如果测试表达式（test Expression）为false，则在else语句主体内执行代码，并跳过if主体内的代码。cout<<"您输入了一个负整数： " << number << endl;cout << "您输入了一个正整数：" << number << endl;cout << "您输入了一个正整数：" << number << endl;" << endl;
C++基础：if判断语句（else拓展）
jinitaimei1123的博客
11-17 2651
C++基础：if语句判断
详解C++编程中的条件判断语句if-else与switch的用法
09-02
主要介绍了C++编程中的条件判断语句if-else与switch的用法,是C++入门学习中的基础知识,需要的朋友可以参考下
基于PL/0语言的扩充——if-then-else,do-while-until,for
06-21
编译原理课程设计，是对PL0语言的扩充。 主要包括if-then-else,do-while-until,for 资源里有我写的报告和源码，c++实现。 需要自己运行测试
C++ if...else优化重构 tcy
tcy-阿春
01-07 1265
1.1.应用：异常逻辑处理和不同状态处理 1.2.缺点：代码逻辑复杂，维护性差，极易引发bug 1.3.重构原则： 正常流程在最外层，保持主干流程是正常核心流程; 避免嵌套过深;减少if语句数目；异常条件先退; 1.4.实现手段： 减少嵌套、移除临时变量、条件取反判断、合并条件表达式等(减少或优化if语句) map处理;工厂模式；策略模式;（删除if语句） 实例1：重构-合并条件表达式 int foo(){//重构前 if(b1)return 0;if(b2)return 0.
多if_else的优化
12-26
本文档对java中if_else的什么时候使用进行说明。。。。
c++ if else
02-20
good programming switch if else
C++第三讲：C++中的逻辑运算符及if else语句
喷火龙廖的博客
11-25 799
刚学完If和逻辑运算，我们一起打开洛谷做一道题目吧！这里他问有几名学生不及格，需要用到计数器“sum”。else{在加上头文件和定义，就AC了。
c++if else 解释
m0_74811974的博客
02-01 464
114514
c++if语句（包含else）
bbbb8989的博客
11-14 516
条件语句
【优化】IF-ELSE 代码结构的优化
sco5282的博客
07-11 2795
1. 前言 代码中，如果 if-else 语句比较多，阅读起来比较困难，维护性较差，很容易出bug。接下来，此文将介绍优化 if-else 代码的八种方案 2. 优化方案 方案一：提前 return，去除不必要的else 如果 if-else 代码块包含 return 语句，可以考虑通过提前 return，把多余 else 干掉，使代码更加优雅 优化前： if (condition) { // TODO } else { return; } 优化后： if (!conditio
怎样优化代码中那么多的if else
北漂码农的博客
04-25 9801
if else 是我们写代码时，使用频率最高的关键词之一，然而有时过多的 if else 会让我们感到脑壳疼。 例如下面这个伪代码： 是不是很崩溃？虽然他是伪代码，并且看起来也很夸张，但在现实中，当我们无数次 Review 别人代码时，都会发现类似的场景。 那么我们本文就来详细聊聊，有没有什么方法可以让我们避免来写这么多的 if else 呢？ 我们本文提供了 9 种...
C++ if 和else判断语句
dgxdgh的博客
01-20 630
if 和else判断 #include <iostream> using namespace std; int main () { // 局部变量声明 int a = 10; // 使用 if 语句检查布尔条件 if( a < 20 ) { // 如果条件为真，则输出下面的语句 cout << "a 小...
c++if-else if-else结构如何用
07-14
在C++中，可以使用if-else if-else结构来进行条件判断和分支控制。if语句用于执行条件为真时的代码块，else if语句用于执行多个条件判断，而else语句用于执行其他情况的代码块（即，当所有的if和else if条件都不满足时执行的代码块）。 下面是if-else if-else结构的基本语法： ```cpp if (条件1) { // 条件1为真时执行的代码块 } else if (条件2) { // 条件1不满足，条件2为真时执行的代码块 } else { // 条件1和条件2都不满足时执行的代码块 } ``` 以下是一个简单的示例，演示了如何使用if-else if-else结构： ```cpp #include <iostream> int main() { int num = 5; if (num > 0) { std::cout << "数字大于0" << std::endl; } else if (num < 0) { std::cout << "数字小于0" << std::endl; } else { std::cout << "数字等于0" << std::endl; } return 0; } ``` 在上述示例中，如果`num`大于0，则输出"数字大于0"；如果`num`小于0，则输出"数字小于0"；否则，输出"数字等于0"。 注意，if-else if-else结构的条件可以是任意的布尔表达式，根据条件的判断结果决定执行哪个代码块。根据实际需求，可以嵌套使用多个if-else if-else结构来实现更复杂的条件判断和分支控制。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值