c语言如何将字符串转为二进制的整型然后保存到整型数组里？

Posted 2023-04-18

int regis5[5]=0,0,0,0,1;
int regis6[6]=0,0,0,0,0,1;
int regis7[7]=0,0,0,0,0,0,1;
如上，我希望能用字符串转化为二进制来初始化它们的值？求高手帮忙
我是用vc编译，有没有具体代码？

参考技术A 你可以把输入的字符串放到一个字符数组里面，然后用一个循环遍历里面的字符，直接把里面的元素赋值给一个整形数组的元素，就行了，只是要注意你的整形数组足够大，才能满足你输入多行字符。追问

能给出代码吗？用c/c++都可以

追答

比想象中简单多了，只要用到getchar()函数
#include
#include
#include
int main(void)

int ch;
int i=0;
int j=0;
int k=0;
int number[1024]=0;
int result[1024][8]=0;
printf("请输入一行字符，以'\n'符结束：\n");

j=0;
while((ch=getchar())!='\n')

i=7;
while (ch!=0)

result[j][i]=ch%2;
i--;
ch/=2;

j++;


for (i=0;i<=j ;i++ )

for (k=0;k<8 ;k++ )

printf("%d ",result[i][k]);

printf("当前的字符数：%d\n",i);

return 0;

我用的是linux c
输出结果是

Elasticsearch：如何将浮点值存储到整型字段中

在我之前的文章 “Elasticsearch：Elasticsearch 中的数据强制匹配” 中，我详述了如何使用 coerce 属性来强制匹配一个不同的数据类型。在今天的文章中，我们来展示 Elasticsearch 是如何把一个浮点数保存到一个不同的数据类型中，比如整型数据类型。

首先，我们来创建一个如下的索引：

PUT my_index/_doc/1
{
  "score": 1
}

我们接下来使用如下的方法来得到上述索引 my_index 里字段的数据类型:

GET my_index/_mapping

上面的命令返回的结果为：

{
  "my_index" : {
    "mappings" : {
      "properties" : {
        "score" : {
          "type" : "long"
        }
      }
    }
  }
}

我们可以看到经过 dynamic mapping，索引中的 score 字段自动被设置为 long 数据类型。

接下来，我们按照如下的方式来摄入更多的数据：

PUT my_index/_doc/2
{
  "score" : 2
}

PUT my_index/_doc/3
{
  "score" : "3"
}

PUT my_index/_doc/4
{
  "score" : 4.5
}

PUT my_index/_doc/5
{
  "score" : "5.1"
}

在上面的命令中，我们发现有些数据不是整型数值，比如 "3", "4.5" 及 “5.1”。那么它们到底是否能被正确无误地写入文档呢？我们分别执行上面的每一个指令，我们发现它们的结果没有任何一个是返回错误的：

{
  "_index" : "my_index",
  "_type" : "_doc",
  "_id" : "5",
  "_version" : 2,
  "result" : "updated",
  "_shards" : {
    "total" : 2,
    "successful" : 1,
    "failed" : 0
  },
  "_seq_no" : 8,
  "_primary_term" : 1
}

这充分地说明了它们的写入是没有任何问题的。如果你对这个还不是特别能够理解，请阅读我之前的文章 “Elasticsearch：Elasticsearch 中的数据强制匹配”。这是因为在默认的情况下, coerce 是 true。它会自动帮我们把数据转换为我们索引所定义的数据类型。也就是说， "3" 字符串会被转换为整数 3 而写入文档内部。那么有人可能会想到查询一下刚才写入的文档：

GET my_index/_search

    "hits" : [
      {
        "_index" : "my_index",
        "_type" : "_doc",
        "_id" : "1",
        "_score" : 1.0,
        "_source" : {
          "score" : 1
        }
      },
      {
        "_index" : "my_index",
        "_type" : "_doc",
        "_id" : "2",
        "_score" : 1.0,
        "_source" : {
          "score" : 2
        }
      },
      {
        "_index" : "my_index",
        "_type" : "_doc",
        "_id" : "3",
        "_score" : 1.0,
        "_source" : {
          "score" : "3"
        }
      },
      {
        "_index" : "my_index",
        "_type" : "_doc",
        "_id" : "4",
        "_score" : 1.0,
        "_source" : {
          "score" : 4.5
        }
      },
      {
        "_index" : "my_index",
        "_type" : "_doc",
        "_id" : "5",
        "_score" : 1.0,
        "_source" : {
          "score" : "5.1"
        }
      }
    ]

上面的结果显示它们和我们之前写入时时完全一模一样的。并没有任何的变化。它们并没有显示为整型值。那么这到底是咋样一回事呢？

_source 只是一种错觉

这个问题的谜底的最后一部分是 Elasticsearch 从不更改 _source。 但是存储的字段 score 与你期望的一样，它是 long 类型的字段。 你可以通过在字段上运行聚合来验证这一点：

GET my_index/_search
{
  "size": 0,
  "aggs": {
    "my_sum": {
      "sum": {
        "field": "score"
      }
    }
  }
}

上面的命令显示的结果是：

{
  "took" : 12,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 5,
      "relation" : "eq"
    },
    "max_score" : null,
    "hits" : [ ]
  },
  "aggregations" : {
    "my_sum" : {
      "value" : 15.0
    }
  }
}

从上面我们可以看出来 my_sum 为 15。它是 1 + 2 + 3 + 4 + 5 = 15，也就是 5 个文档的 long 类型值的总和。

结论

我希望你不像以前那样困惑，或者至少喜欢这个谜题。 作为最后的说明，请注意 coerce 可能在未来被删除，因为它是一个陷阱功能 - 特别是在截断浮点数方面。