Essential C++学习笔记及源代码(第2章 面向过程编程风格)

最新推荐文章于 2022-05-07 10:36:46 发布
最新推荐文章于 2022-05-07 10:36:46 发布
阅读量470 收藏 7
点赞数 6
分类专栏： Essential C++学习(课后习题以及源代码) 文章标签： c++ 编程语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46181359/article/details/118055679
版权

第2章介绍了C++语言中面向过程编程方面
本章介绍了独立函数的众多基本编写原则，并简要讨论了重载(overloaded)以及函数模板(function template)，同时也说明了函数指针的运用技巧。
将函数独立出来的做法可带来3个主要好处：
1、以一连串函数调用操作取代重复编写相同的程序代码，可使程序更容易读懂。
2、我们可以在不同的程序中使用这些函数。
3、我们可以更容易地将工作分配给协作开发团队。
作者在第2章使用了一个冒泡排序的小程序介绍函数的通用操作，并简要讨论了指针和引用的关系，笔者在此汇总并附上课后编程练习使得更好地掌握已学知识，若是对您有用的话请点赞或分享提供给它人。

//ch2_main.cpp

#include <iostream>
#include <fstream>
#include <vector>
using namespace std;

//判断用户输入的位置是否正确;
inline bool is_size_ok(int size)
{
    const int max_size = 1024;
    if (size <= 0 || size > max_size)
    {
        cerr << "Oops: requested size is not supported : " << size;
        cerr << " -- can't fulfill request.\n";
        return false;
    }
    return true;
}

//定义一个静态数列;
inline const vector<int> *fibon_seq(int size)
{
    const int max_size = 1024;
    static vector<int> elems;

    if (!is_size_ok(size))
    {
        return 0;
    }
    for (int ix = elems.size(); ix < size; ++ix)
    {
        if (ix == 0 || ix == 1)
        {
            elems.push_back(1);
        }
        else
        {
            elems.push_back(elems[ix - 1] + elems[ix - 2]);
        }
    }
    return &elems;
}

//查找指定位置的值;
inline bool fibon_elem(int pos, int &elem)
{
    const vector<int> *pseq = fibon_seq(pos);
    if (!pseq)
    {
        elem = 0;
        return false;
    }
    elem = (*pseq)[pos - 1];
    return true;
}

//交换2个元素;
inline void swap(int &val1, int &val2)
{
    int temp = val1;
    val1 = val2;
    val2 = temp;
    return;
}

//冒泡排序;
inline void bubble_sort(vector<int> &vec, ofstream &os = cout)
{
    for (int ix = 0; ix < vec.size(); ++ix)
    {
        for (int jx = ix + 1; jx < vec.size(); ++jx)
        {
            if (vec[ix] > vec[jx])
            {
                swap(vec[ix], vec[jx]);
            }
        }
    }
    os << "The sorted datas:" << endl;
    return;
}

//打印数列;
inline void display(const vector<int> &vec, ofstream &os = cout)
{
    for (int ix = 0; ix < vec.size(); ++ix)
    {
        os << vec[ix] << ' ';
    }
    os << endl;
    return;
}

//显示数列中指定位置的值;
inline bool print_sequence(int pos)
{
    if (pos <= 0 || pos > 1024)
    {
        cerr << "invalid position: " << pos;
        cerr << " -- cannot handle request!\n";
        return false;
    }
    cout << "The Fibonacci Sequence for ";
    cout << pos << " positions: \n\t";
    switch (pos)
    {
    default:
    case 2:
    {
        cout << "1 ";
    }
    case 1:
    {
        cout << "1 ";
        break;
    }
    }
    int elem;
    int n_2 = 1, n_1 = 1;
    for (int ix = 3; ix <= pos; ++ix)
    {
        elem = n_2 + n_1;
        n_2 = n_1;
        n_1 = elem;
        cout << elem << (!(ix % 10) ? "\n\t" : " "); //每10个元素打印换行符和制表符;
    }
    cout << endl;
    return true;
}

//测试冒泡排序;
void test_bubble_sort()
{
    int ia[8] = {8, 34, 3, 13, 1, 21, 5, 2};
    vector<int> vec(ia, ia + 8);

    bubble_sort5(vec);
    display(vec);
    ofstream ofil("sorted_data.txt");
    bubble_sort(vec, ofil);
    display(vec, ofil);
    return;
}

//测试查找指定位置上数列的值;
void test_num_sequence()
{
    int pos, elem;

    cout << "Please enter a position: ";
    cin >> pos;
    if (fibon_elem(pos, elem))
    {
        cout << "element # " << pos;
        cout << " is " << elem << endl;
    }
    else
    {
        cout << "Sorry. Could not calculate element # ";
        cout << pos << endl;
    }
    print_sequence(pos);
    return;
}

int main()
{
    test_num_sequence();
    test_bubble_sort();

    return 0;
}

//-----------------------------------------------------------;

//-----------------------------------------------------------;
//Practise2.1.cpp

#include <iostream>
using namespace std;

inline bool fibon_elem(int pos, int &elem); //查找指定位置的值;
inline bool print_sequence(int pos);        //显示数列中指定位置的值;

int main()
{
    char ch;
    int pos, elem;

    while (true)
    {
        cout << "Please enter a position: ";
        cin >> pos;
        if (fibon_elem(pos, elem))
        {
            cout << "element # " << pos;
            cout << " is " << elem << endl;
        }
        else
        {
            cout << "Sorry. Could not calculate element # ";
            cout << pos << endl;
        }
        print_sequence(pos);
        cout << "Would you like to try again? (y/n) ";
        cin >> ch;
        if (ch != 'y' && ch != 'Y')
        {
            break;
        }
    }
    cout << "Bye." << endl;

    return 0;
}

bool fibon_elem(int pos, int &elem)
{
    if (pos <= 0 || pos > 1024)
    {
        elem = 0;
        return false;
    }
    elem = 1;
    int n_2 = 1, n_1 = 1;
    for (int ix = 3; ix <= pos; ++ix)
    {
        elem = n_2 + n_1;
        n_2 = n_1;
        n_1 = elem;
    }
    return true;
}

bool print_sequence(int pos)
{
    if (pos <= 0 || pos > 1024)
    {
        cerr << "invalid position: " << pos;
        cerr << " -- cannot handle request!\n";
        return false;
    }
    cout << "The Fibonacci Sequence for ";
    cout << pos << " positions: \n\t";
    switch (pos)
    {
    default:
    case 2:
    {
        cout << "1 ";
    }
    case 1:
    {
        cout << "1 ";
        break;
    }
    }
    int elem;
    int n_2 = 1, n_1 = 1;
    for (int ix = 3; ix <= pos; ++ix)
    {
        elem = n_2 + n_1;
        n_2 = n_1;
        n_1 = elem;
        cout << elem << (!(ix % 10) ? "\n\t" : " "); //每10个元素打印换行符和制表符;
    }
    cout << endl;
    return true;
}

//-----------------------------------------------------------;

//-----------------------------------------------------------;
//Practise2.2.cpp

#include <iostream>
#include <vector>
using namespace std;

inline bool gen_pentagonal(vector<int> &vec, int pos);
inline void display_elems(vector<int> &vec, const string &title);

int main()
{
    vector<int> pent;
    const string title("Pentagonal Numeric Series");

    if (gen_pentagonal(pent, 0))
    {
        display_elems(pent, title);
    }
    if (gen_pentagonal(pent, 8))
    {
        display_elems(pent, title);
    }
    if (gen_pentagonal(pent, 14))
    {
        display_elems(pent, title);
    }
    if (gen_pentagonal(pent, 138))
    {
        display_elems(pent, title);
    }

    return 0;
}

bool gen_pentagonal(vector<int> &vec, int pos)
{
    if (pos <= 0 || pos > 64)
    {
        cerr << "Sorry. Invalid position: " << pos << endl;
        return false;
    }
    for (int i = vec.size() + 1; i <= pos; ++i)
    {
        vec.push_back((i * (3 * i - 1)) / 2);
    }
    return true;
}

void display_elems(vector<int> &vec, const string &title)
{
    cout << title << endl;
    for (int ix = 0; ix < vec.size(); ++ix)
    {
        cout << vec[ix] << ' ';
    }
    cout << endl;
    return;
}

//-----------------------------------------------------------;

//-----------------------------------------------------------;
//Practise2.3.cpp

#include <iostream>
#include <vector>
using namespace std;

inline bool gen_pentagonal(vector<int> &vec, int pos);
inline void help_pentagonal(vector<int> &vec, int pos);
inline void display_elems(vector<int> &vec, const string &title);

int main()
{
    vector<int> pent;
    const string title("Pentagonal Numeric Series");

    if (gen_pentagonal(pent, 0))
    {
        display_elems(pent, title);
    }
    if (gen_pentagonal(pent, 8))
    {
        display_elems(pent, title);
    }
    if (gen_pentagonal(pent, 14))
    {
        display_elems(pent, title);
    }
    if (gen_pentagonal(pent, 138))
    {
        display_elems(pent, title);
    }

    return 0;
}

bool gen_pentagonal(vector<int> &vec, int pos)
{
    if (pos <= 0 || pos > 64)
    {
        cerr << "Sorry. Invalid position: " << pos << endl;
        return false;
    }
    if (vec.size() < pos)
    {
        help_pentagonal(vec, pos);
    }
    return true;
}

void help_pentagonal(vector<int> &vec, int pos)
{
    for (int i = vec.size() + 1; i <= pos; ++i)
    {
        vec.push_back((i * (3 * i - 1)) / 2);
    }
    return;
}

void display_elems(vector<int> &vec, const string &title)
{
    cout << title << endl;
    for (int ix = 0; ix < vec.size(); ++ix)
    {
        cout << vec[ix] << ' ';
    }
    cout << endl;
    return;
}

//-----------------------------------------------------------;

//-----------------------------------------------------------;
//Practise2.4.cpp

#include <iostream>
#include <vector>
using namespace std;

inline const vector<int> *gen_pentagonal(int pos);
inline bool pentagonal_elem(int pos, int &elem);

int main()
{
    int elem;

    if (pentagonal_elem(8, elem))
    {
        cout << "element 8 is " << elem << endl;
    }
    if (pentagonal_elem(88, elem))
    {
        cout << "element 88 is " << elem << endl;
    }
    if (pentagonal_elem(12, elem))
    {
        cout << "element 12 is " << elem << endl;
    }
    if (pentagonal_elem(64, elem))
    {
        cout << "element 64 is " << elem << endl;
    }

    return 0;
}

inline const vector<int> *gen_pentagonal(int pos)
{
    static vector<int> pent;
    if (pos > 0 && pos <= 64 && pos > pent.size())
    {
        for (int i = pent.size() + 1; i <= pos; ++i)
        {
            pent.push_back((i * (3 * i - 1)) / 2);
        }
    }
    return &pent;
}

inline bool pentagonal_elem(int pos, int &elem)
{
    if (pos <= 0 || pos > 64)
    {
        cerr << "Sorry. Invalid position: " << pos << endl;
        elem = 0;
        return false;
    }
    const vector<int> *pent = gen_pentagonal(pos);
    elem = (*pent)[pos - 1];
    return true;
}

//-----------------------------------------------------------;

//-----------------------------------------------------------;
//Practise2.5.cpp

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;

inline int max(int t1, int t2)
{
    return t1 > t2 ? t1 : t2;
}

inline float max(float t1, float t2)
{
    return t1 > t2 ? t1 : t2;
}

inline string max(const string &t1, const string &t2)
{
    return t1 > t2 ? t1 : t2;
}

inline int max(const vector<int> &vec)
{
    return *max_element(vec.begin(), vec.end());
}

inline float max(const vector<float> &vec)
{
    return *max_element(vec.begin(), vec.end());
}

inline string max(const vector<string> &vec)
{
    return *max_element(vec.begin(), vec.end());
}

inline int max(const int parray[], int size)
{
    return *max_element(parray, parray + size);
}

inline float max(const float parray[], int size)
{
    return *max_element(parray, parray + size);
}

inline string max(const string parray[], int size)
{
    return *max_element(parray, parray + size);
}

int main()
{
    string sarray[6] = {"we", "were", "her", "pride", "of", "ten"};
    vector<string> svec(sarray, sarray + 6);

    int iarray[7] = {12, 70, 2, 169, 1, 5, 29};
    vector<int> ivec(iarray, iarray + 7);

    float farray[5] = {2.5, 24.8, 18.7, 4.1, 23.9};
    vector<float> fvec(farray, farray + 5);

    int imax = max(max(ivec), max(iarray, 7));
    float fmax = max(max(fvec), max(farray, 5));
    string smax = max(max(svec), max(sarray, 6));

    cout << "imax should be 169  -- found: " << imax << "\n";
    cout << "fmax should be 24.8 -- found: " << fmax << "\n";
    cout << "smax should be were -- found: " << smax << "\n";

    return 0;
}

//-----------------------------------------------------------;

//-----------------------------------------------------------;
//Practise2.6.cpp

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;

template <typename T>
T max(T &t1, T &t2)
{
    return t1 > t2 ? t1 : t2;
}

template <typename elemtype>
elemtype max(const vector<elemtype> &t)
{
    return *max_element(t.begin(), t.end());
}

template <typename arraytype>
arraytype max(const arraytype parray[], int size)
{
    return *max_element(parray, parray + size);
}

int main()
{
    string sarray[6] = {"we", "were", "her", "pride", "of", "ten"};
    vector<string> svec(sarray, sarray + 6);

    int iarray[7] = {12, 70, 2, 169, 1, 5, 29};
    vector<int> ivec(iarray, iarray + 7);

    float farray[5] = {2.5, 24.8, 18.7, 4.1, 23.9};
    vector<float> fvec(farray, farray + 5);

    int imax = max(max(ivec), max(iarray, 7));
    float fmax = max(max(fvec), max(farray, 5));
    string smax = max(max(svec), max(sarray, 6));

    cout << "imax should be 169  -- found: " << imax << "\n";
    cout << "fmax should be 24.8 -- found: " << fmax << "\n";
    cout << "smax should be were -- found: " << smax << "\n";

    return 0;
}

//-----------------------------------------------------------;

//--------------------2021年6月19日 -------------------------

MZZDX
关注
  • 6
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Essential C++ 笔记（2）：泛型编程风格（中）
bwqiang的博客
04-03 241
继续上一个博文的内容： 5、使用泛型算法 使用泛型算法，需要包含的头文件是： #include<algorithm> find()函数用于查询无序序列中是否存在某值，存在则返回一个iterator指向该值，否则返回一个iterator指向end。 binary_search()用于有序集合的搜索。成功返回true，否则返回false。 count()返回序列中数值相等的元素的个数。...
Essential C++中文版+完整源代码+习题答案
02-23
Essential_C++ 程序源代码 本書的所有程式，以及習題解答中的完整程式碼，皆可線上取得。你可以在 Addison Wesley Longman 的網站（www.awl.com/cseng/titles/0-201-48518-4）或我的個人首頁（www.objectwrite.com）...
【阅读笔记】《essential C++》
weixin_43152152的博客
11-03 414
《essential c++》源码 1.2 对象的定义与初始化 “构造函数语法”初始化变量 int number(0); 1.5 如何运用Array和Vector 数组初始化vector int arr[5] = {1, 2, 3, 4, 5}; //way 1 vector vec(arr, arr+5); vector vec(arr, arr+arr.size()) //error 暂时不知道原因 //way 2 vector vec(begin(arr), end(arr)); 1.7 文件的读
《Essential C++》学习笔记
m0_50816320的博客
02-17 3812
书籍介绍 大名鼎鼎的《C++ Primer》作者为了照顾想快速入门C++的"初学者"而编写的入门书籍，全书不足300页却包含C++的大量重要知识，关于此书的由来读者可以自行去阅读此书的前言，这里不再赘述。 此文由来 关于这个文章，其实也是我自己给我的一个挑战，这本书虽然精简，短短不足300页，但是大量的语法，原理一笔带过，很难在几句话的功夫理解一类知识的思想，换句话说，《C++ Primer》太长，很多人读不下去，而这本书太短，又需要一定的注解，解释来辅助理解，所以这篇文章由此诞生，我希望通过这个机会，让
Essential C++源代码
04-28
Essential C++源代码，包括书内每章节案例源码及练习题答案源码。目录结构清晰，便于学习。附pdf版《Essential C++》
Essential C++学习笔记及源代码(第4章 基于对象编程风格)
CLOVER的博客
07-21 430
第4章介绍了C++语言中使用Class进行基于对象的编程的方式 导言：一般而言，class由两部分组成：一组公开的(public)操作函数和运算符，以及一组私有的(private)实现细节。这些操作函数和运算符称为class的成员函数，并代表这个class的公开接口。身为class的用户只能访问其公开接口。这也就是我们使用string、vector等标准模板库的方式。例如，针对string的成员函数size()，我们只知道其原型声明，即参数列表为void，返回一个整数值。 1、Class的private实现
essential c++源代码
07-18
本书将C++的基本内容按照过程风格、泛型风格、基于对象风格，以及面向对象风格进行组织。本书采用复杂度渐进的风格展开，并在讨论解决方案的过程中引入语言特性，便于学习C++的功能和结构，同时理解其目的和基本理念...
Essential C++ (中文版PDF) 附加源代码
01-06
《Essential C++》是一本针对C++编程语言的基础教程，中文版的PDF形式使得国内读者更容易理解。这本书由Stanley B. Lippman撰写，他是一位在C++领域有着深厚造诣的专家，其作品通常深受程序员喜爱。"Primer C++缩减...
Essential C++习题代码
04-16
书中的习题代码涵盖了从基本语法到面向对象编程、模板、异常处理等多个方面，是学习C++不可或缺的实践资料。 1. **C++基础语法**：C++作为一种静态类型的、编译式的、通用的、大小写敏感的、不仅支持过程化编程，也...
Essential C++源码（source code）
11-06
int main() { string first_name, last_name; cout <> first_name; cout << "hi, " << first_name <> last_name; cout << '\n'; << "Hello, " << first_name << ' ' << last_name << " ... and goodbye!\n"; }
Essential C++带源码
10-15
本书是C++初学者的入门经典读物。全书从4个方面来展现C++的本质：procedLJral(过程化的)、gerleric(泛型的)、object—based(基于对象的)、object—oriented(面向对象的)。本书的组织围绕着一系列由浅入深的程序设计问题，介绍了用以解决这些问题的语言特性。按照这种方式，读者不但能学到C++的函数和结构，还会学习到它们的设计目的和基本原理。本书涉猎范围广泛，内容涉及C++语言发展的主要几个方面，适合有一定基础的C++初学者。
Essential C++中文版.pdf
03-17
本书以四个面向来表现C++的本质：procedural（面向过程的）、generic（泛型的）、obj-based（基于对象的）、object-oriented（面向对象的）。
Essential C++中文版
04-02
Essential C++中文版 Essential C++中文版
Essential C++学习笔记及源代码(第3章 泛型编程风格)
CLOVER的博客
07-06 360
第3章介绍了C++语言中使用标准模板库(STL)进行泛型编程的方式 导言：Standard Template Library(STL)主要由2种组件构成：一是容器包括vector、list、set、map等class；另一种组件是用以操作这些容器的泛型算法，包括find()、sort()、replace()、merge()等。 1、vector和list是顺序性容器。在顺序性容器上可以进行和常规数组一样的迭代方式。set和map属于关联性容器。关联性容器可以快速地查找容器中的元素值。 2、map是一对对的k
EssentialC++
cz的博客
05-07 1032
第一章 C++编程基础 1.1 如何写c++程序 #include <iostream> //输入输出库 #include <string> int main() //main函数 程序入口 { string user_name; std::cout << "Enter your name" << std::endl; std::cin >> user_name; std::cout << "hell
设置mysql密码永不过期_详解源码安装MySQL
weixin_39629075的博客
11-20 221
一、安装单实例1、升级openssl#查看版本openssl version#openssl 安装包 openssl-1.1.0j.tar.gz #下载地址https://www.openssl.org/source/cd /usr/local/openssl-1.1.1./configmakemake install#受影响的文件夹#/usr/local/bin#/usr/local/inclu...
Essential C++第二章 面向过程的编程风格
Felix_hyfy的博客
08-05 236
Essential C++第二章 面向过程的编程风格如何编写函数相关概念调用函数相关概念重点提供默认参数值重点使用局部静态对象相关概念重点声明inline函数提供重载函数相关概念定义并使用模板函数相关概念重点函数指针带来更大的弹性相关概念重点设定头文件 如何编写函数 相关概念 函数的定义（返回类型、函数名、参数列表、函数体）、函数的声明（函数原型）（返回类型、函数名、参数列表） 调用函数 相关概念...
Essential C++ 第二章代码
BL0SS0M努力学编程
10-16 894
把第二章几乎所有内容都揉在了这个程序里.......... #fibon.h #ifndef FIBON_H_INCLUDED #define FIBON_H_INCLUDED #include #include using namespace std; //inline函数必须定义在头文件中//还用到了参数默认值inline bool is_size_ok(in
essential c++目录
最新发布
07-18
第二章：函数 这一章详细讲解了C语言中的函数，包括函数的定义、调用和参数传递等。还介绍了如何使用函数解决实际问题。 第三章：数组和字符串 这一章讲解了C语言中的数组和字符串的概念和用法。读者将学会如何处理...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

MZZDX

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值