fread读结构体返回值是0无错误_【C++新特性】C++17结构化绑定

最新推荐文章于 2022-09-27 16:56:11 发布
最新推荐文章于 2022-09-27 16:56:11 发布
阅读量155 收藏
点赞数
文章标签： fread读结构体返回值是0无错误 matlab 结构体内容引用自非结构体数组对象 matlab结构体内容引用自非结构体数组对象 尝试引用非结构体数组的字段 并非所有变量都已绑定 什么原因 结构体内容引用自非结构体数组对象

  • 1.1 更详细的阐述结构化绑定

    • 1.1.1 绑定到匿名对象

    • 1.1.2 使用修饰符

    • 1.1.3 修饰符并非修饰结构化绑定

    • 1.1.4 移动语义

  • 1.2 结构化绑定可以在哪使用

    • 1.2.1 结构体和类

    • 1.2.2 原生数组

    • 1.2.3 std::pair,std::tuple和std::array

  • 1.3 为结构化绑定提供类似tuple的API

    • 1.3.1 只读结构化绑定

    • 1.3.2 结构化绑定写操作

1.结构化绑定

结构化绑定：通过对象的元素或成员初始化多个实体。

一个结构体如下：

struct MyStruct {
  int i = 0;
  std::string s;
};

我们可以将一个MyStruct对象绑定到两个变量上。

MyStruct ms;
auto [u, v] = ms;

在这里，u和v就是所谓的结构化绑定。将结构体的成员分解初始化了u、v变量。

结构化绑定对于返回结构或数组的函数特别有用。

例如：返回一个结构体函数

MyStruct getStruct() {
  return MyStruct{42, "hello"};
};

此时我们可以直接通过结构化绑定拿到结构体的成员。

auto [id, val] = getStruct();

另一个比较有意思的使用地方在于可以增加代码可读性，例如输出map中所有的键值对。map如下：

std::map<int, std::string> mymap = {{1, "el"}, {3, "tom"}, {4, "nic"}};

结构化绑定之前我们遍历给定的是无意义的elem。

for (const auto& elem : mymap) {
  std::cout <": "  <std::endl;
}

有了结构体绑定之后，我们只需要[key, val]。

for (const auto& [key, val] : mymap) {
  std::cout <": " <std::endl;
}

在这里我们可以清晰的看出结构化绑定的语义。

1.1 更详细的阐述结构化绑定

结构化绑定中匿名变量非常重要，结构化绑定引入的新名字的都是指代的这个匿名遍历的成员、元素。

1.1.1 绑定到匿名对象

先考虑如下绑定到匿名变量：

auto [u, v] = ms;

可以看作:

auto e = ms; // e是匿名变量
aliasname u = e.i;
aliasname v = e.s;

这里需要注意一点的是，u与v不是e.i与e.s的引用。它们只是这两个成员的别名。其中e是匿名变量，所以我们不能直接访问e.i与e.s，但是可以访问u与v，例如：

std::cout <": " <std::endl;

这个例子输出e.i与e.s的值，它们是ms.i和ms.s的一份拷贝。

匿名变量e的生命周期同结构化绑定的存活时间一样，当结构化绑定离开作用域时，e会同时析构。

在这里我们还需要理解引用，通过结构化绑定，利用前面的例子：

MyStruct ms{42, "hello"};
auto [u, v] = ms;
ms.i = 100;
std::cout <": " <std::endl; // 42: 100
u = 101;
std::cout <": " <std::endl; // 101: 100

第一次输出42: 100，u是ms.i的一份拷贝，而修改了ms.i并不会影响u，因此输出是42: 100。第二次输出101:100，直接修改了u，同样u是ms.i的一份拷贝，修改了不会影响ms.i，因此输出是101: 100。现在我们换成引用：

auto& [u1, v1] = ms;
ms.i = 100;
std::cout <": " <std::endl;
u1 = 101;
std::cout <": " <std::endl;

此时第一次输出是100: 100 第二次输出是101: 101

同理，对返回值使用结构化绑定，上面规则一样成立。

auto [u, v] = getStruct();

转换为：

auto e = getStruct();
aliasname u = e.i;
aliasname v = e.s;

可以看到结构化绑定是绑定到一个新的对象，由返回值进行初始化，而不是直接绑定到返回值本身。

另外，内存地址和对齐也是存在。如果成员有对齐，结构化绑定也会存在对齐，例如：

auto [u, v] = ms;
assert(&((MyStruct*)&u)->s == &v);

1.1.2 使用修饰符

结构化绑定中我们可以使用一些修饰符，如：const和&。

这里的修饰符是加在匿名变量上。

const auto& [u, v] = ms;

等价于

const auto& e = ms;
aliasname u = e.i;
aliasname v = e.s;

引用对结果的影响可以看前面绑定到匿名对象的例子。

1.1.3 修饰符并非修饰结构化绑定

修饰符修饰的是匿名变量，而不是结构化绑定。尽管在结构化绑定的时候会使用到auto，但是结构化绑定的类型不会退化(数组转指针、修饰符被忽略等)。例如：

struct S {
  const char x[6];
  const char y[3];
};

调用：

S s1;
auto [a, b] = s1;

我们查看a与b的类型发现，还是const char[6]与const char[3]，说明并没有发生退化为指针，原因是修饰符并非修饰结构化绑定而是修饰初始化结构体绑定的对象, 这一点和使用auto初始化新对象很不一样，它会发生类型退化。

auto a2 = a;

退化为const char*。

1.1.4 移动语义

结构化绑定也支持移动语义，例如：

MyStruct ms = {42, "Jim"};
auto&& [u, v] = std::move(ms);

等价于：

MyStruct ms = {42, "Jim"};
auto&& e = std::move(ms);
aliasname u = e.i;
aliasname v = e.s;

结构化绑定u和v指向匿名变量中的成员，该匿名变量是ms的右值引用。ms仍然持有它的值:

std::cout <": " <std::endl;

此时还可以移动赋值u与v，例如v与ms.s关联。

std::string s = std::move(v);
std::cout <std::endl;
std::cout <std::endl;
std::cout <std::endl;

此时ms.s与v输出的是未指定的值，s输出的是Jim。移动后的对象(如前面v)的状态是有效的，只是包含了未指定的值(unspecified value)。因此，输出它的值是没有问题的，但是不能断言输出的东西一定是什么。

这一点和直接移动ms的值给匿名变量稍有不同：


MyStruct ms1 = {42, "Jim"};
auto [u1, v1] = std::move(ms1);  // new entity with moved-from values from ms
std::cout <"ms1.s: " <std::endl;  // prints unspecified value
std::cout <"v1: " <std::endl;        // prints "Jim"

仍然可以移动n并赋值，或者用它赋予一个新的值，但是不会影响ms.s：

std::string s = std::move(v1);  // moves v1 to s
v1 = "Lara";
std::cout <"ms.s: " <std::endl;  // prints unspecified value
std::cout <"v1: " <std::endl;      // prints "Lara"
std::cout <"s: " <std::endl;        // prints "Jim"

1.2 结构化绑定可以在哪使用

原则上，结构化绑定可以应用于public成员、C-style数组、类似tuple对象。具体如下：

  • public非静态成员 结构体或类中的非静态成员是public

  • 原生数组 绑定到每个元素

  • 任何类型，使用类似tuple的API

std::tuple_size::value 返回元素数量std::tuple_element::type 返回第idx个元素的类型 一个全局或成员函数get()返回idx个元素的值

使用的时候需要元素或数据成员的数量必须匹配结构化绑定的名字的个数。不能跳过任何一个元素，也不能使用同一个名字多次，但是可以使用_跳过当前元素。

切记不要在同一命名空间使用多次_。

auto [_, v1] = getStruct(); // OK
auto [_, v2] = getStruct(); // ERROR: name _ already used

嵌套对象分解是不支持的，诸如：

auto [a,(b,c)] = (3,(4,2));

1.2.1 结构体和类

结构化绑定不适用于继承，所有非静态数据成员必须在同一个类。

换句话说，这些数据成员要么全是基类，要么全是子类。

例如：

struct B {
  int a{1};
  int b{2};
};

struct D1 : public B {};
struct D2 : public B {
  int c{3};
};

struct B1 {};

struct D3 : public B1 {
  int c{3};
};

int main() {
  auto [x, y] = D1{};     // 全部来自于基类
  auto [z] = D3{};        // 全部来自于子类
  auto [i, j, k] = D2{};  // 编译时错误 无法分解
  return 0;
}

1.2.2 原生数组

数组长度已知的情况下，可以结构化绑定到多个变量上。

C++允许我们返回带长度的数组引用：

auto getArr() -> int(&)[2] {

}
auto [x, y] = getArr();

同样可以对std::array进行结构化绑定。

1.2.3 std::pair,std::tuple和std::array

结构化绑定可扩展，可以为任何类型添加结构化绑定，标准库中使用到的有std::pair，std::tuple,std::array

1.std::array

std::array<int, 4> getArray();
auto [i,j,k,l] = getArray();

同样，如果需要更改原生数组里面的值可以改为：

std::array<int, 4> stdarr{1, 2, 3, 4};
auto& [i, j, k, l] = stdarr;
i += 10;

2.std::tuple

std::tuple<char, float, std::string> getTuple() {
  std::tuple<char, float, std::string> tp('1', 6.6, "hello");
  return tp;
}
auto [a, b, c] = getTuple();

3.std::pair

处理关联/无序容器的insert()调用的返回值，使用结构化绑定使代码可读性更强，可以更加清晰的表达自己的一图，而不是依赖与std::pair的first与second。

C++ 17之前写法：

std::map<std::string, int> coll;
auto ret = coll.insert({"new",42});
if (!ret.second) {
  // if insert failed, handle error using iterator pos:
}

C++17之后：

std::map<std::string, int> coll;
auto [pos,ok] = coll.insert({"new",42});
if (!ok) {
  // if insert failed, handle error using iterator pos:
}

可以看到C++17提供了一种表达力更强的带初始化的if。

4.为pair和tuple的结构化绑定赋值

声明了结构化绑定之后，通常不能一次性修改全部结构化绑定，因为结构化绑定是一次性声明所有。如果重新赋值是std::pair<>或std::tuple<>，可以使用std::tie();

std::tuple<char,float,std::string> getTuple() { }
auto [a, b, c] = getTuple();
std::tie(a, b, c) = getTuple(); // next returned tuple

尤其适用于在循环中不停地赋值例如下面查找例子：

在text中查找sub

std::string text =
    "Lorem ipsum dolor sit amet, consectetur adipiscing elit,"
    " sed do eiusmod tempor incididunt ut labore et dolore magna aliqua";

std::string sub = "dolor";
std::boyer_moore_searcher bm{sub.begin(), sub.end()};
for (auto [beg, end] = bm(text.begin(), text.end()); beg != text.end();
     std::tie(beg, end) = bm(end, text.end())) {
  // find sub in text
  std::cout <"find sub string in text string, start pos is "
            <std::endl;
}

1.3 为结构化绑定提供类似tuple的API

只要我们的类型实现了类似tuple的API，那么就可以针对该类型使用结构化绑定，这样便可以从std::pair<>,std::tuple<>,和std::array<>推广到任意类型。

1.3.1 只读结构化绑定

首先，定义一个类：

class Customer {
 private:
  std::string first;
  std::string last;
  long val;

 public:
  Customer(std::string f, std::string l, long v)
      : first(std::move(f)), last(std::move(l)), val(v) {}
  std::string getFirst() const { return first; }
  std::string getLast() const { return last; }
  long getValue() const { return val; }
};

提供类似tuple的API:

template <>
struct std::tuple_size {static constexpr int value = 3;
};template <>struct std::tuple_element<2, Customer> {using type = long;
};template <std::size_t Idx>struct std::tuple_element {using type = std::string;
};template <std::size_t>auto get(const Customer& c);template <>auto get<0>(const Customer& c) {return c.getFirst();
}template <>auto get<1>(const Customer& c) {return c.getLast();
}template <>auto get<2>(const Customer& c) {return c.getValue();
}

对get进行封装，使用编译时if特性：

template <std::size_t I>
auto get(const Customer& c) {
  static_assert(I 3);
  if constexpr (I == 0) {
    return c.getFirst();
  } else if constexpr (I == 1) {
    return c.getLast();
  } else {  // I == 2
    return c.getValue();
  }
}

有了这些API，结构化绑定就可以在main函数中使用。

int main() {
  Customer c("Tim", "Starr", 42);
  auto [f, l, v] = c;
  std::cout <"f/l/v: " <' ' <' ' <'\n';
  // modify structured bindings:
  std::string s = std::move(f);
  l = "Waters";
  v += 10;
  std::cout <"f/l/v: " <' ' <' ' <'\n';
  std::cout <"c: " <' ' <' '
            <'\n';
  std::cout <"s: " <'\n';
  return 0;
}

输出：

f/l/v: Tim Starr 42
f/l/v:  Waters 52
c: Tim Starr 42
s: Tim

1.3.2 结构化绑定写操作

在上述Customer中对成员函数进行修改：

class Customer {
 private:
  std::string first;
  std::string last;
  long val;

 public:
  Customer(std::string f, std::string l, long v)
      : first(std::move(f)), last(std::move(l)), val(v) {}
  const std::string& firstname() const { return first; }
  std::string& firstname() { return first; }
  const std::string& lastname() const { return last; }
  std::string& lastname() { return last; }
  long value() const { return val; }
  long& value() { return val; }
};

要支持读写，需要对常量引用和非常量引用准备getter重载：分别支持非常量对象、常量对象、可移动对象,为了返回引用，应该使用decltype(auto)

// define specific getters:
template <std::size_t I>
decltype(auto) get(Customer& c) {
  static_assert(I 3);
  if constexpr (I == 0) {
    return c.firstname();
  } else if constexpr (I == 1) {
    return c.lastname();
  } else {  // I == 2
    return c.value();
  }
}
template <std::size_t I>
decltype(auto) get(const Customer& c) {
  static_assert(I 3);
  if constexpr (I == 0) {
    return c.firstname();
  } else if constexpr (I == 1) {
    return c.lastname();
  } else {  // I == 2
    return c.value();
  }
}
template <std::size_t I>
decltype(auto) get(Customer&& c) {
  static_assert(I 3);
  if constexpr (I == 0) {
    return std::move(c.firstname());
  } else if constexpr (I == 1) {
    return std::move(c.lastname());
  } else {  // I == 2
    return c.value();
  }
}

std::tuple_size<>与std::tuple_element<>不变。

// provide a tuple-like API for class Customer for structured bindings:
template <>
struct std::tuple_size {static constexpr int value = 3;  // we have 3 attributes
};template <>struct std::tuple_element<2, Customer> {using type = long;  // last attribute is a long
};template <std::size_t Idx>struct std::tuple_element {using type = std::string;  // the other attributes are strings
};

同样，getter方法也可以不用编译时if，如下：

// 支持非const对象
template <std::size_t>
decltype(auto) get(Customer& c);
template <>
decltype(auto) get<0>(Customer& c) {
  return c.firstname();
}
template <>
decltype(auto) get<1>(Customer& c) {
  return c.lastname();
}
template <>
decltype(auto) get<2>(Customer& c) {
  return c.value();
}
// 支持const对象
template <std::size_t>
auto get(const Customer& c);
template <>
auto get<0>(const Customer& c) {
  return c.firstname();
}
template <>
auto get<1>(const Customer& c) {
  return c.lastname();
}
template <>
auto get<2>(const Customer& c) {
  return c.value();
}

// 支持移动对象
template <std::size_t>
decltype(auto) get(Customer&& c);
template <>
decltype(auto) get<0>(Customer&& c) {
  return std::move(c.firstname());
}
template <>
decltype(auto) get<1>(Customer&& c) {
  return std::move(c.lastname());
}
template <>
decltype(auto) get<2>(Customer&& c) {
  return std::move(c.value());
}

调用：

int main() {
  Customer c("Tim", "Starr", 42);
  auto [f, l, v] = c;
  std::cout <"f/l/v: " <' ' <' ' <'\n';
  // modify structured bindings via references:
  auto&& [f2, l2, v2] = c;
  std::string s = std::move(f2);
  f2 = "Ringo";
  v2 += 10;
  std::cout <"f2/l2/v2: " <' ' <' ' <'\n';
  std::cout <"c: " <' ' <' ' <            <'\n';
  std::cout <"s: " <'\n';
  return 0;
}

输出：

f/l/v: Tim Starr 42
f2/l2/v2: Ringo Starr 52
c: Ringo Starr 52
s: Ti

学习自Cpp17TheCompleteGuide

d107f28880117dfa3a54d812ca01024b.png

weixin_39612110
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
fread 返回 0
cyang's blog
07-25 4132
fread 函数一直返回 0，检查过读取的数量不会超过文件大小，错误发生在打开文件时错误。 错误代码如下： FILE *in_file, *out_file; unsigned int open_files(const char *in_file_name, const char *out_file_name) { if( in_file = fopen(in_file_name,...
fread 返回 0的情况
ytuglt的博客
07-16 2073
fread 的函数原型是（来自MSDN）： size_t fread( void *buffer, size_t size,size_t count,FILE *stream);   我们用fread读的时候，有时会把size设置为整数，比如：300。然后我们可能用一个循环来读取文件的内容： while ((iBytesRead = fread (buf, 300, 1, fin))> 0)
fread总返回0的问题
akashequ的专栏
05-16 1万+
  size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);这个函数以前一直没理解为什么 size_t size, size_t nmemb参数来确定读取缓冲区的大小，我开始以为两个可以互换，而且在有些场合互换确实也没问题，直到今天碰到了打开一个文件，读取的长度总是返回0。事例代码如下：char buffer
C++11新特性总结
小杰312的博客
02-22 2万+
C++11新特性总结
fread读结构体返回值是0无错误_嵌入式C编程之错误处理（附代码例子）！
weixin_39640909的博客
11-29 310
原标题：嵌入式C编程之错误处理(附代码例子)！作者： clover-toeic前言本文主要总结嵌入式系统C语言编程中，主要的错误处理方式。文中涉及的代码运行环境如下：一、错误概念 错误分类从严重性而言，程序错误可分为致命性和非致命性两类。对于致命性错误，无法执行恢复动作，最多只能在用户屏幕上打印出错消息或将其写入日志文件，然后终止程序；而对于非致命性错误，多数本质上是暂时的(如资源短缺)，一般恢复...
为什么fread(),fwrite()的返回值总是为0,但是读写文件正常
12-15
为什么fread(),fwrite()的返回值总是为0,但是文件读写正常 初学C语言文件操作的新人,总会犯这个错误,明明文件读 写成功 ,但是返回值总是为0,而不是读写成功的字节数,原因是因为...
hj1.rar_C++读取wav文件_pcm_读取pcm文件_读取wav_音频pcm
07-15
C语言读取WAV PCM音频文件的头文件
为什么fwrite写文件后,用fread读出来文件长度是0,即fread读不出数据
03-31
为什么fwrite写文件后,用fread读出来文件长度是0,即fread读不出数据
readBil.rar_bil_fread matlab_hyperspectral_matlab高光谱_读取bil
07-15
采用Matlab下fread函数读取高光谱BIL文件数据
c++相关技术 fread
05-08
c++ 读文件 fread是一个函数。从一个文件流中读数据，最多读取count个元素，每个元素size字节，如果调用成功返回实际读取到的元素个数，如果不成功或读到文件末尾返回 0。
C++17新特性个人总结
热门推荐
我的博客
05-20 3万+
目录 C++17 1 关键字 1.1 constexpr 1.2 static_assert 1.3 auto 1.4 typename 1.5 inline 2 语法 2.1 折叠表达式 2.2 结构化绑定 2.3 允许非类型模板参数进行常量计算 2.4 条件分支语句初始化 2.5 聚合初始化 2.6 嵌套命名空间 2.7 lambda表达式捕获*this的值...
C++17 新特性介绍
langshanglibie的专栏
09-27 6586
C++17 新特性介绍
std::tuple类型
人无远虑，必有近忧
02-16 1256
std::tuple是类似std::pair的模板。每个pair的成员类型都不相同，但每个pair都恰好有两个成员。不同std::tuple类型的成员类型也不相同，但一个std::tuple可以有任意数量的成员。每个确定的std::tuple类型的成员数目是固定的，但一个std::tuple类型的成员数目可以与另一个std::tuple类型不同。
c++17好用的新特性总结
独行猫a 的沉淀、积累、总结。天天学习，好好向上...c/c++,嵌入式 linux,Android,HarmonyOS)
05-20 1万+
自从C++11开始，标志着c++的复兴和现代C++的开端。尽管有各种新语言层出不穷，但涉及性能和系统层面c++仍然是首选，地位无可撼动。 比如最近很火的鸿蒙系统框架代码，很多就是基于c++做的底层、运行时和应用框架封装。c++11后续又有11，14，17，20等众多新版本。哪个是主流？ 截至目前来说，c++17应该是新项目的首选。C++14在11的基础上查缺补漏，并未加入许多新特性，而C++17作为C++11后的第一个大版本，标志着现代C++逐渐走向成熟。 这里总结下C++17在业务代
关于spark中的问题
hxbdc56的博客
09-09 1924
1.在spark中使用scala语言，它会自动判定一个读取的rdd是键值对还是元组， 当一个键值对和元组合并时就会出现如下错误 Unspecified value parameters: numPartitions: Int. Unspecified value parameters: partitioner: Partitioner. Type mismatch, expected: RDD[(...
Scala编程语言入门学习笔记
m0_37118493的博客
03-01 1103
数据类型和操作符 数据类型 （1）值类型和引用类型 （2）值类型是类类型，相当于java中的包装类，没有基本数据类型和包装类之分 scala> 1 to 10 res4: scala.collection.immutable.Range.Inclusive = Range 1 to 10 scala> 1.to(10) res5: scala.collection.immutable...
scala入门（一）
weixin_44273391的博客
09-21 201
scala入门（一） 数据类型 变量名； 数据类型 变量名 = 初始化值； scala 定义变量 var 变量名 = 初始化值 var 变量名：数据类型=初始化值 var a=1 定义变量的时候需要初始化值 定义变量的时候可以不指定变量的数据类型，系统会根据变量的初始化值推断变量的数据类型 scala定义常量 val 变量 =初始化值 val 变量：数据类型=初始化值 val修饰的变量，相当于ja...
c语言中fread读取结构体,fread读取结构体注意事项
weixin_31473773的博客
05-21 2625
作者 ： 卿笃军函数原型size_tfread (void*buffer,size_tsize,size_tcount,FILE*stream) ;参 数buffer用于接收数据的内存地址size要读写的字节数，单位是字节count要进行读写多少个size字节的数据项,每个元素是size字节.stream输入流返回值实际读取的元素个数.如果返回值与count不相同,则可能文件结尾或发...
【C++新特性】C++17结构化绑定
Francis的博客
10-15 5745
1.1 更详细的阐述结构化绑定1.1.1 绑定到匿名对象1.1.2 使用修饰符1.1.3 修饰符并非修饰结构化绑定1.1.4 移动语义1.2 结构化绑定可以在哪使用1.2.1 结构体和类...
c语言fread函数读结构体
最新发布
04-30
如果要读取结构体，可以先定义一个结构体类型，然后使用 fread 函数将数据读入到该结构体变量中。 例如，如果有一个名为 person 的结构体类型，包含 name 和 age 两个成员变量，可以使用以下代码读取二进制文件中的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值