bool是啥类型

Posted 2023-05-06

bool是一个什么类型？bool a; a = 5;printf("%d", a);运行结果是1，我用的是C89标准。

bool是布尔类型用作逻辑判断。

bool表示布尔型变量，也就是逻辑型变量的定义符，以英国数学家、布尔代数的奠基人乔治·布尔命名。bool类似于float,double等，只不过float定义浮点型，double定义双精度浮点型。 在objective-c中提供了相似的类型BOOL，它具有YES值和NO值；在java中则对应于boolean类型。

扩展资料：

bool的长度视实际环境来定，一般可认为是4个字节。如果数个bool对象列在一起，可能会各占一个Byte，这取决于编译器。

C99标准定义了bool类型的大小是至少能够存放0和1这两个值。并没有规定具体的大小。这交给编译器自由发挥了。gcc编译器对待bool类型有自己的转换处理。如果是0赋值给bool类型，那么就赋值0。如果是任意其他数据，那么会赋值为1。

参考技术A

bool表示布尔型

bool以英国数学家、布尔代数的奠基人乔治·布尔（George Boole）命名。bool类似于float,double等，只不过float定义浮点型，double定义双精度浮点型。 在objective-c中提供了相似的类型BOOL，它具有YES值和NO值。

bool取值false和true，0为false，非0为true。（例如-1和2都是true）。如果数个bool对象列在一起，可能会各占一个Byte，这取决于编译器。BOOL是微软定义的typedef int BOOL(在windef.h中)，0为FALSE，1为TRUE。

扩展资料

应用举例——

#include<iostream>

#include<windef.h>

using namespace std;

int main()

BOOL b =2; //执行此行后，b=2(BOOL为int此处不进行类型转换，b存放的就是2)。

if(b)

cout << "ok!" << endl;

b=b-1; //执行此行后，b=1(只是简单的进行算术运算，结果为1，回存)

if(b) // b非0，条件为真

cout << "error!" <<endl;

return 0;

运行结果：OK!

error!

参考技术B

Bool 在C++里是一个数据类型但是只有两个选择。真或假 true or false。

bool Answer;
if(Answer)//if(Answer)就是如果答案是真的，if（!Answer）就是错的或假的

Score+=1;

也可以说成
if(Answer==true) 或 if（Answer==false)

拓展资料：

C++是C语言的继承，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行以继承和多态为特点的面向对象的程序设计。

C++不仅拥有计算机高效运行的实用性特征，同时还致力于提高大规模程序的编程质量与程序设计语言的问题描述能力，还可以进行基于过程的程序设计，因而C++就适应的问题规模而论，大小由之。

参考技术C bool为布尔型
bool是布尔型变量，也就是逻辑型变量的定义符，类似于float,double等，只不过float定义浮点型，double定义双精度浮点型。 在objective-c中提供了相似的类型BOOL，它具有YES值和NO值。
布尔型变量的值只有 真 （true) 和假 （false）。
布尔型变量可用于逻辑表达式，也就是“或”“与”“非”之类的逻辑运算和大于小于之类的关系运算，逻辑表达式运算结果为真或为假。
bool可用于定义函数类型为布尔型，函数里可以有 return TRUE; return FALSE 之类的语句。 参考技术D bool 布尔型 只有 true真 和 false假 ， true 是 1， false 是 0。赋值时，非0元素赋给布尔型，则为1。

在构造 std::variant 时禁用从指针类型到 bool 的隐式转换的最佳方法是啥？

【中文标题】在构造 std::variant 时禁用从指针类型到 bool 的隐式转换的最佳方法是啥？

【英文标题】：What is the best way to disable implicit conversion from pointer types to bool when constructing an std::variant?在构造 std::variant 时禁用从指针类型到 bool 的隐式转换的最佳方法是什么？

【发布时间】：2020-10-07 18:03:55

【问题描述】：

考虑以下几点：

struct foo 
;

struct bar 
;

int main()

    foo f;
    bar b;
    std::variant<foo*, bool> v;
    v = &b; // compiles in Visual Studio 19 v16.7.3

正如 cmets 中所讨论的，我相信以上是合法的 C++17。有一个提案 P0608R3 被接受为解决这种令人惊讶的行为的标准，但它在 2018 年（在圣地亚哥会议上）被接受，因此适用于 C++20 而不是 C++17。此外，P0608R3 目前未在 Visual Studio 中实现，即使编译为 C++20 预览版也是如此。

从指向非 foo 的指针创建此变体的最佳/最简洁的方法是编译时错误？ 我相信以下内容有效，但如果变体包含多个项目，则会有很多样板。

struct foo 
;

struct bar 
;

using variant_type = std::variant<foo*, bool>;
struct var_wrapper : public variant_type

    var_wrapper(foo* v = nullptr) : variant_type(v)
    

    var_wrapper(bool v) : variant_type(v)
    

    template<typename T>
    var_wrapper(T*) = delete;
;

int main()

    foo f;
    bar b;

    var_wrapper vw;
    vw = &f; // fine
    vw = true; // fine
    vw = &b; // compile time error

我错过了一些更简单的方法吗？

【问题讨论】：

在我看来像 error。

这对我来说似乎是一个错误。 cppreference 表示如果类型列表包含一个可能有 cv 限定的bool，那么只有当它的参数恰好是一个可能有 cv 限定的bool 时，该类型才应该由operator= 激活。也就是说，不应进行隐式转换。

@jwezorek 根据docs.microsoft.com/en-us/cpp/overview/…，这个 (P0608R3) 还没有在 MSVC 标准库中实现。

恐怕你是对的。

【参考方案1】：

另一种解决方案是引入另一个 bool 包装器，该包装器除了 bool 之外不构造任何东西：

#include <variant>

struct foo ;
struct bar ;

struct StrongBool 
    bool value = false;

    StrongBool() noexcept = default;
    StrongBool(bool b) noexcept : value(b) 

    template<class T>
    StrongBool(T) = delete;
;

int main() 
    foo f;
    bar b;
    std::variant<foo*, StrongBool> v;
    v = true;
    v = &f;
    v = &b; // fails to compile
 

无论如何，限制可接受的初始化器需要引入带有用户定义构造函数的类型包装器。

【参考方案2】：

如果 std::variant 的行为有问题，我认为处理隐式转换的最简洁方法是使用“强变体”类型。即，实现一个变体类型，它只使用完全变体中的类型强制构造。

使用 std::disjunction 可以很容易地测试一个类型是否是 C++17 中参数包的成员，导致实现如下：

template<typename... Ts>
class strong_variant : public std::variant<Ts...> 

public:
    template <typename T, typename U = 
        typename std::enable_if<std::disjunction_v<std::is_same<T, Ts>...>>::type>
    strong_variant(T v) : std::variant<Ts...>(v)
    

    strong_variant() : std::variant<Ts...>()
    
;

struct foo ;
struct bar ;

int main()

    foo f;
    bar b;
    const foo c_f;

    strong_variant<foo*, std::string, bool> sv;

    sv = &f; // okay.
    sv = true; // okay.
    sv = "foo"s; // okay.

    sv = "foo"; //no, must a string.
    sv = &b;  // no, must be a foo.
    sv = &c_f; // no, must be non-const.

【讨论】：

很高兴您得到了解决方案，感谢您的分享，如果您将它们标记为答案，我将不胜感激，这将对其他社区有益。