C++ Primer (第五版）第六章习题部分答案

2024-03-20 06:44
文章标签 c++ 答案 部分 第六章 习题 primer 第五版

本文主要是介绍C++ Primer (第五版）第六章习题部分答案，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

        在我自学C++过程中，我选择了C++Primer这本书，并对部分代码习题进行了求解以及运行结果。接下来几个月我将为大家定时按章节更新习题答案与运行结果，运行环境（Visual Studio Code，windows 11）：

C++ Primer (第五版）习题答案总目录：

https://blog.csdn.net/weixin_48467622/article/details/136418131?spm=1001.2014.3001.5501

6.1 实参和形参的区别的什么？

形参在函数的定义中声明；
实参是形参的初始值。

6.2 请指出下列函数哪个有错误，为什么？应该如何修改这些错误呢？

(a) int f() {string s;// ...return s;}
(b) f2(int i) { /* ... */ }
(c) int calc(int v1, int v1) { /* ... */ }
(d) double square (double x)  return x * x;

(a)函数声明返回类型为int，实际返回类型为string：

string f() {  // return should be string, not intstring s;// ...return s;
}

(b)需要加上函数类型声明：

void f2(int i) { /* ... */ }  // function needs return type

(c)形参的名字不能相同：

int calc(int v1, int v2) { /* ... */ }  // parameter list cannot use same name twice

(d)需要有大括号（函数块）：

double square (double x) { return x * x; }  // function body needs braces

6.3 编写你自己的fact函数，上机检查是否正确。

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>#include <iterator>
using namespace std;int fact(int val)
{int ret = 1;while (val > 1){ret *= val;val--;}return ret;
}
int main()
{int j = fact(5);cout << j << endl;return 0;
}

6.4 编写一个与用户交互的函数，要求用户输入一个数字，计算生成该数字的阶乘。在main函数中调用该函数。

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>#include <iterator>
using namespace std;int fact(int val)
{int ret = 1;while (val > 1){ret *= val;val--;}return ret;
}
int main()
{int n;cin >> n;int j = fact(n);cout << j << endl;return 0;
}

6.5 编写一个函数输出其实参的绝对值。

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>#include <iterator>
using namespace std;int abs(int val)
{int ret;if (val >= 0){ret = val;}else{ret = -val;}return ret;
}
int main()
{int n;cin >> n;int j = abs(n);cout << j << endl;return 0;
}

6.6 说明形参、局部变量以及局部静态变量的区别。编写一个函数，同时达到这三种形式。

形参：定义在函数形参列表里面；

局部变量：定义在代码块里面；

局部静态变量：在程序的执行路径第一次经过对象定义语句时初始化，并且直到程序终止时才被销毁。

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>#include <iterator>
using namespace std;size_t cadd(int val)//val是一个形参和局部变量
{static size_t ctr = 0;//ctr是一个局部静态变量ctr += val;return ctr;
}
int main()
{for (int i = 0; i < 10; i++)//i是一个局部变量{cout << cadd(i) << endl;}return 0;
}

6.7 编写一个函数，当它第一次被调用时返回0，以后每次被调用返回值加1。

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>#include <iterator>
using namespace std;size_t count_calls()
{static size_t ctr = 0;return ctr++;
}
int main()
{for (int i = 0; i < 10; i++)//i是一个局部变量{cout << count_calls() << endl;}return 0;
}

6.8 编写一个名为Chapter6.h 的头文件，令其包含6.1节练习中的函数声明。

#pragma once
#ifndef CHAPTER6_H
#define CHAPTER6_Hint fact(int val);
int abs(int val);#endif

6.9 编写你自己的fact.cc 和factMain.cc ，这两个文件都应该包含上一小节的练习中编写的 Chapter6.h 头文件。通过这些文件，理解你的编译器是如何支持分离式编译的。

Chapter.h

#pragma once
#ifndef CHAPTER6_H
#define CHAPTER6_Hint fact(int val);
int abs1(int val);#endif

fact.cpp

#include "Chapter.h"int fact(int val)
{int ret = 1;while (val > 1){ret *= val;val--;}return ret;
}int abs1(int val)
{int ret;if (val >= 0){ret = val;}else{ret = -val;}return ret;
}

factMain.cpp

#include "Chapter.h"
#include<iostream>
using namespace std;int main()
{cout << fact(6) << endl;cout << abs1(-6) << endl;return 0;
}

6.10 编写一个函数，使用指针形参交换两个整数的值。在代码中调用该函数并输出交换后的结果，以此验证函数的正确性。

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>#include <iterator>
using namespace std;void swap(int* a, int* b)
{int t = *a;*a = *b;*b = t;
}
int main()
{int x = 6, y = 66;cout << x << " " << y << endl;swap(&x, &y);cout << x << " " << y << endl;return 0;
}

6.11 编写并验证你自己的reset函数，使其作用于引用类型的参数。

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>#include <iterator>
using namespace std;void reset(int& i)
{i = 66;
}
int main()
{int val = 60;cout << val << endl;reset(val);cout << val << endl;return 0;
}

​

6.12 改写6.2.1节练习中的程序，使其引用而非指针交换两个整数的值。你觉得哪种方法更易于使用呢？为什么？

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>#include <iterator>
using namespace std;void swap(int& a, int& b)
{int t = a;a = b;b = t;
}
int main()
{int x = 6, y = 66;cout << x << " " << y << endl;swap(x, y);cout << x << " " << y << endl;return 0;
}

​

引用更易于使用，不用考虑传递的是指针，避免语法错误；
使用引用避免拷贝。

6.13 假设 T 是某种类型的名字，说明以下两个函数声明的区别：一个是void f(T), 另一个是 void f(&T)。

void f(T)
将实参的值拷贝后赋给形参，不能通过改变形参的值来改变实参；
void f(&T)
使用引用将形参绑定到实参上，可以通过改变形参来改变实参。

6.14 举一个形参应该是引用类型的例子，再举一个形参不能是引用类型的例子。

应该是引用：

void reset(int &i)
{i = 0;
}

不能是引用：

void print(std::vector<int>::iterator begin, std::vector<int>::iterator end)
{for (std::vector<int>::iterator iter = begin; iter != end; ++iter)std::cout << *iter << std::endl;
}

6.15 说明find_char 函数中的三个形参为什么是现在的类型，特别说明为什么s是常量引用而occurs是普通引用？为什么s和occurs是引用类型而c不是？如果令s是普通引用会发生什么情况？如果令occurs是常量引用会发生什么情况？

s不需要改变实参，occurs需要改变实参；s可能会很大，occurs需要改变实参，c没有上述两个需求；如果s是普通的引用可能改变实参；occurs是常量引用则不能改变实参，++occurs会报错。

6.16 下面的这个函数虽然合法，但是不算特别有用。指出它的局限性并设法改善。

bool is_empty(string& s) { return s.empty(); }

该函数无需改变实参，故将其设置为const比较好，这样也可以传入const类型的字符串，或字符串字面值。

bool is_empty(const string& s) { return s.empty(); }

6.17 编写一个函数，判断string对象中是否含有大写字母。编写另一个函数，把string对象全部改写成小写形式。在这两个函数中你使用的形参类型相同吗？为什么？

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>#include <iterator>
using namespace std;bool isupper(const string& s)
{for (auto c : s){if (isupper(c)){return true;}}return false;
}void toupper(string& s)
{for (auto& c : s){c = tolower(c);}
}
int main()
{string s1 = "Hello The USA!";cout << isupper(s1) << endl;cout << s1 << endl;toupper(s1);cout << s1 << endl;return 0;
}

6.18 为下面的函数编写函数声明，从给定的名字中推测函数具备的功能。

  • (a) 名为 compare 的函数，返回布尔值，两个参数都是 matrix 类的引用。
  • (b) 名为 change_val 的函数，返回vector的迭代器，有两个参数：一个是int，另一个是vector的迭代器
（a）bool compare(matrix &m1,matrix &m2);
（b）vector<int>::iterator change_val(int i,vector<int>::iterator);

6.19 假定有如下声明，判断哪个调用合法、哪个调用不合法。对于不合法的函数调用，说明原因。

double calc(double);
int count(const string &, char);
int sum(vector<int>::iterator, vector<int>::iterator, int);
vector<int> vec(10);
(a) calc(23.4, 55.1);
(b) count("abcda",'a');
(c) calc(66);
(d) sum(vec.begin(), vec.end(), 3.8);

（a）不合法，只能一个形参；
（b）合法；
（c）合法；
（d）合法。

6.20 引用形参什么时候应该是常量引用？如果形参应该是常量引用，而我们将其设为了普通引用，会发生什么情况？

无需改变实参的时候应该用常量引用；可能会改变常亮实参，从而导致出错。

6.21 编写一个函数，令其接受两个参数：一个是int型的数，另一个是int指针。函数比较int的值和指针所指的值，返回较大的那个。在该函数中指针的类型应该是什么？

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>#include <iterator>
using namespace std;void comp(int a, int* b)
{cout << ((a > *b) ? a : *b )<< endl;
}
int main()
{int x = 1, i = 3;int* y = &i;comp(x, y);return 0;
}

int型

6.22 编写一个函数，令其交换两个int指针。

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>#include <iterator>
using namespace std;void swap(int* &a, int* &b)
{int* t;t = a;a = b;b = t;
}
int main()
{int a = 6, b = 66;int* i = &a, * j = &b;cout << *i << " " << *j << endl;swap(i, j);cout << *i << " " << *j << endl;return 0;
}

6.23 参考本节介绍的几个print函数，根据理解编写你自己的版本。依次调用每个函数使其输入下面定义的i和j:

int i = 0 , j[2] = {0 , 1};
#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>#include <iterator>
using namespace std;void print1(const int a, const int *b)
{cout << "print1:" << endl;cout << "i:" << a << endl;cout << "j:" << endl;for(int i=0;i<2;i++){cout << *b++ << " ";}cout << endl;
}
void print2(const int a, const int b[])
{cout << "print2:" << endl;cout << "i:" << a << endl;cout << "j:" << endl;for (int i = 0; i < 2; i++){cout << *b++ << " ";}cout << endl;
}
void print3(const int a, const int b[2])
{cout << "print3:" << endl;cout << "i:" << a << endl;cout << "j:" << endl;for (int i = 0; i < 2; i++){cout << *b++ << " ";}cout << endl;
}
int main()
{int i = 0, j[2] = { 0,1 };print1(i, j);print2(i, j);print3(i, j);return 0;
}

6.24 描述下面这个函数的行为。如果代码中存在问题，请指出并改正。

void print(const int ia[10])
{for (size_t i = 0; i != 10; ++i)cout << ia[i] << endl;
}

该函数传递的不是数组是const int*，如果实参不是含10个元素的int数组，可能导致for循环数组越界。修改为：

void print(const int （&ia）[10])
{for (size_t i = 0; i != 10; ++i)cout << ia[i] << endl;
}

6.25 编写一个main函数，令其接受两个实参。把实参的内容连接成一个string对象并输出出来。

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>#include <iterator>
using namespace std;int main(int argc,char const *argv[])
{cout << "argc:" << argc << endl;string a1 = argv[1], a2 = argv[2], a3 = argv[3];cout << a1 + a2 + a3<< endl;return 0;
}

6.26 编写一个程序，使其接受本节所示的选项；输出传递给main函数的实参内容。

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>#include <iterator>
using namespace std;int main(int argc,char const *argv[])
{cout << "argc:" << argc << endl;for (int i = 0; i < argc; i++){cout << argv[i] << " ";}cout << endl;return 0;
}

6.27 编写一个函数，它的参数是initializer_list类型的对象，函数的功能是计算列表中所有元素的和。

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>
#include <initializer_list>
#include <iterator>
using namespace std;
int count_int(initializer_list<int> i1)
{int cnti = 0;for (auto i : i1){cnti += i;}return cnti;
}
int main()
{cout << count_int({ 1,2,3,4,5,6,7 }) << endl;return 0;
}

6.29 在范围for循环中使用initializer_list对象时，应该将循环控制变量声明成引用类型吗？为什么？

如果拷贝代价小，则无需设置成引用类型；如果拷贝代价大，可以设置成引用类型。

6.30 编译第200页的str_subrange函数，看看你的编译器是如何处理函数中的错误的。

错误#1：error: return-statement with no value, in function returning ‘bool’ [-fpermissive]
错误#2：检查不出，返回true

6.31 什么情况下返回的引用无效？什么情况下返回常量的引用无效？

返回的引用时局部对象的引用，返回的常量引用是局部常量对象的引用时。

6.32 下面的函数合法吗？如果合法，说明其功能；如果不合法，修改其中的错误并解释原因。

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>
#include <initializer_list>
#include <iterator>
using namespace std;
int& get(int* array, int index) 
{ return array[index];
}
int main()
{int ia[10];for (int i = 0; i != 10; ++i)get(ia, i) = i;for (auto j : ia)cout << j << " ";cout << endl;
}

6.33 编写一个递归函数，输出vector对象的内容。

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>
#include <initializer_list>
#include <iterator>
using namespace std;
void CoutVector(vector<int>::const_iterator iter_begin, vector<int>::const_iterator iter_end)
{if (iter_begin != iter_end){cout << *iter_begin << " ";CoutVector(++iter_begin, iter_end);}else{cout << endl;return;}
}
int main()
{vector<int> v{ 1,2,3,4,5,6,7,8,9 };CoutVector(v.begin(), v.end());return 0;
}

6.34 如果factorial 函数的停止条件如下所示，将发生什么？

if (val != 0)

如果实参为大于等于0，函数将会多乘以一个1，比如factorial(5)，等价于5 * 4 * 3 * 2 * 1 * 1;
如果实参小于0，函数将会不断地调用它自身直到程序栈空间耗尽为止。

6.35  在调用factorial函数时，为什么我们传入的值是 val-1 而非 val--？

val--会返回未修改的val内容，使程序陷入无限循环；val--会修改val的内容，使程序运行结果不符合预期。

6.36 编写一个函数声明，使其返回数组的引用并且该数组包含10个string对象。不用使用尾置返回类型、decltype或者类型别名。

string (&func(string (&arr)[10]))[10];

6.37 为上一题的函数再写三个声明，一个使用类型别名，另一个使用尾置返回类型，最后一个使用decltype关键字。你觉得哪种形式最好？为什么？

using arrt = string[10];
arrt &func(arrt &arrs);
auto func(atring a)->string(&)[10];
string a[10];
decltype(a) &func(string qq);

6.38 修改arrPtr函数，使其返回数组的引用。

decltype(odd)& arrPtr(int i)
{return (i % 2) ? odd : even;
}

6.39 说明在下面的每组声明中第二条语句是何含义。如果有非法的声明，请指出来。

(a) int calc(int, int);int calc(const int, const int);
(b) int get();double get();
(c) int *reset(int *);double *reset(double *);

（a）非法，重复声明可以，重复定义不行，第二个非引用非指针；

（b）非法，仅返回值不同；
（c）合法，重载关系。

6.40 下面的哪个声明是错误的？为什么？

(a) int ff(int a, int b = 0, int c = 0);
(b) char *init(int ht = 24, int wd, char bckgrnd);

(a)正确

(b)因为一旦某个形参被赋予了默认值，那么它之后的形参都必须要有默认值。

6.41 下面的哪个调用是非法的？为什么？哪个调用虽然合法但显然与程序员的初衷不符？为什么？

char *init(int ht, int wd = 80, char bckgrnd = ' ');
(a) init();
(b) init(24,10);
(c) init(14,'*');

（a）非法，函数第一个形参没有默认实参，必须给实参；
（b）合法；
（c）合法，但与初衷不符，char '*'转换成整形了。

6.42 给make_plural函数的第二个形参赋予默认实参’s’, 利用新版本的函数输出单词success和failure的单数和复数形式。

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>
#include <initializer_list>
#include <iterator>
using namespace std;string make_plural(size_t ctr, const string& word, const string& ending = "s")
{return (ctr > 1) ? word + ending : word;
}
int main()
{cout << make_plural(2, "success", "es") << endl;cout << make_plural(2, "failture") << endl;return 0;
}

6.43 你会把下面的哪个声明和定义放在头文件中？哪个放在源文件中？为什么？

(a) inline bool eq(const BigInt&, const BigInt&) {...}
(b) void putValues(int *arr, int size);

（a）放在头文件中，内联函数在程序中可以多次定义，它的多个定义必须完全一致，所以放在头文件中比较好；
（b）放在头文件中，声明放在头文件中。

6.44 将6.2.2节的isShorter函数改写成内联函数。

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>
#include <initializer_list>
#include <iterator>
using namespace std;inline bool inShorter(const string& s1, const string& s2)
{return s1.size() < s2.size();
}
int main()
{string s1("aaadd"), s2("dadaddf");cout << inShorter(s1, s2);return 0;
}

6.45 回顾在前面的练习中你编写的那些函数，它们应该是内联函数吗？如果是，将它们改写成内联函数；如果不是，说明原因。

6.38和6.42应该是内联函数；6.4不应该是，规模不小，调用不频繁。

6.46 能把isShorter函数定义成constexpr函数吗？如果能，将它改写成constxpre函数；如果不能，说明原因。

不能，因为std::string::size()； 不是一个constexpr函数，s1.size() == s2.size()； 不是一个常量表达式。

6.47 改写6.3.2节练习中使用递归输出vector内容的程序，使其有条件地输出与执行过程有关的信息。例如，每次调用时输出vector对象的大小。分别在打开和关闭调试器的情况下编译并执行这个程序。

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>
#include <initializer_list>
#include <iterator>
using namespace std;
void CoutVector(vector<int>::const_iterator iter_begin, vector<int>::const_iterator iter_end)
{#ifndef NDEBUGcerr << iter_end - iter_begin << __func__ << " " << __FILE__ << " "<< __LINE__ << " " << __TIME__ << " " << __DATE__ << endl;#endifif (iter_begin != iter_end){cout << *iter_begin << " ";CoutVector(++iter_begin, iter_end);}else{cout << endl;return;}
}
int main()
{vector<int> v{ 1,2,3,4,5,6,7,8,9 };CoutVector(v.begin(), v.end());return 0;
}

打开调试器：

关闭调试器：

6.49 什么是候选函数？什么是可行函数？

候选函数具备两个特征：一是与被调用的函数同名，二是其声明在调用点可见。
可行函数是从候选函数中选出的，有两个特征：一是其形参数量与本次调用提供的实参数量相等，二是每个实参的类型与对应的形参类型相同，或者能转换成形参的类型。

6.51 编写函数f的4版本，令其各输出一条可以区分的消息。验证上一个练习的答案，如果你的回答错了，反复研究本节内容直到你弄清自己错在何处。

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>
#include <initializer_list>
#include <iterator>
using namespace std;
void f()
{cout << "Function is f()" << endl;
}void f(int)
{cout << "Function is f(int)" << endl;
}void f(int , int)
{cout << "Function is f(int ,int)" << endl;
}void f(double,double = 3.14)
{cout << "Function is f(double,double = 3.14)" << endl;
}
int main()
{f();f(1);f(1, 2);f(1.1);return 0;
}

6.54 编写函数的声明，令其接受两个int形参并返回类型也是int；然后声明一个vector对象，令其元素是指向该函数的指针。

vector<int (*)(int, int)> vf;//others:
int func(int a, int b);using pFunc1 = decltype(func) *;
typedef decltype(func) *pFunc2;
using pFunc3 = int (*)(int a, int b);
using pFunc4 = int(int a, int b);
typedef int(*pFunc5)(int a, int b);
using pFunc6 = decltype(func);vector<pFunc1> vec1;
vector<pFunc2> vec2;
vector<pFunc3> vec3;
vector<pFunc4*> vec4;
vector<pFunc5> vec5;
vector<pFunc6*> vec6;

6.55 编写4个函数，分别对两个int值执行加、减、乘、除运算；在上一题创建的vector对象中保存指向这些函数的指针。

int add(int a, int b) { return a + b; }
int subtract(int a, int b) { return a - b; }
int multiply(int a, int b) { return a * b; }
int divide(int a, int b) { return b != 0 ? a / b : 0; }

6.56 调用上述vector对象中的每个元素并输出结果。

#include <iostream>
#include <cstring>
#include <vector>
#include <stdexcept>
#include <initializer_list>
#include <iterator>
using namespace std;
int add(int a, int b) 
{ return a + b;
}
int subtract(int a, int b) 
{ return a - b; 
}
int multiply(int a, int b) 
{ return a * b; 
}
int divide(int a, int b) 
{ return b != 0 ? a / b : 0; 
}int main()
{vector<int(*)(int, int)> vf;vf = { add,subtract,multiply,divide };for (auto& c : vf){cout << c(6, 3) << endl;}return 0;
}

这篇关于C++ Primer (第五版）第六章习题部分答案的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/828600。

相关文章

深入理解C++ 空类大小

深入理解C++ 空类大小

《深入理解C++空类大小》本文主要介绍了C++空类大小,规定空类大小为1字节,主要是为了保证对象的唯一性和可区分性,满足数组元素地址连续的要求,下面就来了解一下... 目录1. 保证对象的唯一性和可区分性2. 满足数组元素地址连续的要求3. 与C++的对象模型和内存管理机制相适配查看类对象内存在C++中，规
阅读更多...
在 VSCode 中配置 C++ 开发环境的详细教程

在 VSCode 中配置 C++ 开发环境的详细教程

《在VSCode中配置C++开发环境的详细教程》本文详细介绍了如何在VisualStudioCode（VSCode）中配置C++开发环境,包括安装必要的工具、配置编译器、设置调试环境等步骤,通... 目录如何在 VSCode 中配置 C++ 开发环境：详细教程1. 什么是 VSCode？2. 安装 VSCo
阅读更多...
C++11的函数包装器std::function使用示例

C++11的函数包装器std::function使用示例

《C++11的函数包装器std::function使用示例》C++11引入的std::function是最常用的函数包装器,它可以存储任何可调用对象并提供统一的调用接口,以下是关于函数包装器的详细讲解... 目录一、std::function 的基本用法1. 基本语法二、如何使用 std::function
阅读更多...
【C++ Primer Plus习题】13.4

【C++ Primer Plus习题】13.4

大家好,这里是国中之林! ❥前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站。有兴趣的可以点点进去看看← 问题: 解答: main.cpp #include <iostream>#include "port.h"int main() {Port p1;Port p2("Abc", "Bcc", 30);std::cout <<
阅读更多...
C++包装器

C++包装器

包装器 在 C++ 中，“包装器”通常指的是一种设计模式或编程技巧，用于封装其他代码或对象，使其更易于使用、管理或扩展。包装器的概念在编程中非常普遍，可以用于函数、类、库等多个方面。下面是几个常见的 “包装器” 类型： 1. 函数包装器 函数包装器用于封装一个或多个函数，使其接口更统一或更便于调用。例如，std::function 是一个通用的函数包装器，它可以存储任意可调用对象（函数、函数
阅读更多...
C++11第三弹：lambda表达式 | 新的类功能 | 模板的可变参数

C++11第三弹：lambda表达式 | 新的类功能 | 模板的可变参数

🌈个人主页： 南桥几晴秋 🌈C++专栏： 南桥谈C++ 🌈C语言专栏： C语言学习系列 🌈Linux学习专栏： 南桥谈Linux 🌈数据结构学习专栏： 数据结构杂谈 🌈数据库学习专栏： 南桥谈MySQL 🌈Qt学习专栏： 南桥谈Qt 🌈菜鸡代码练习： 练习随想记录 🌈git学习： 南桥谈Git 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈�
阅读更多...
【C++】_list常用方法解析及模拟实现

【C++】_list常用方法解析及模拟实现

相信自己的力量，只要对自己始终保持信心，尽自己最大努力去完成任何事，就算事情最终结果是失败了，努力了也不留遗憾。💓💓💓 目录   ✨说在前面 🍋知识点一：什么是list？ •🌰1.list的定义 •🌰2.list的基本特性 •🌰3.常用接口介绍 🍋知识点二：list常用接口 •🌰1.默认成员函数 🔥构造函数（⭐） 🔥析构函数 •🌰2.list对象
阅读更多...
06 C++Lambda表达式

06 C++Lambda表达式

lambda表达式的定义 没有显式模版形参的lambda表达式 [捕获] 前属性 (形参列表) 说明符 异常 后属性 尾随类型 约束 {函数体} 有显式模版形参的lambda表达式 [捕获] <模版形参> 模版约束 前属性 (形参列表) 说明符 异常 后属性 尾随类型 约束 {函数体} 含义 捕获：包含零个或者多个捕获符的逗号分隔列表 模板形参：用于泛型lambda提供个模板形参的名
阅读更多...
6.1.数据结构-c/c++堆详解下篇（堆排序，TopK问题）

6.1.数据结构-c/c++堆详解下篇（堆排序，TopK问题）

上篇：6.1.数据结构-c/c++模拟实现堆上篇（向下，上调整算法，建堆，增删数据）-CSDN博客 本章重点 1.使用堆来完成堆排序 2.使用堆解决TopK问题 目录 一.堆排序 1.1 思路 1.2 代码 1.3 简单测试 二.TopK问题 2.1 思路(求最小)： 2.2 C语言代码（手写堆） 2.3 C++代码（使用优先级队列 priority_queue）
阅读更多...
poj 2976 分数规划二分贪心（部分对总体的贡献度） poj 3111

poj 2976 分数规划二分贪心（部分对总体的贡献度） poj 3111

poj 2976： 题意： 在n场考试中，每场考试共有b题，答对的题目有a题。 允许去掉k场考试，求能达到的最高正确率是多少。 解析： 假设已知准确率为x，则每场考试对于准确率的贡献值为： a - b * x，将贡献值大的排序排在前面舍弃掉后k个。 然后二分x就行了。 代码： #include <iostream>#include <cstdio>#incl
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2