C++ Practical-1 day3

已于 2024-09-24 08:35:21 修改
阅读量962 收藏 24
点赞数 28
分类专栏： C++ 文章标签： c++ java 开发语言
于 2024-09-24 08:04:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wesigj/article/details/142475173
版权

系列文章目录

点击直达——文章总目录

文章目录

C++ Practical-1 day3

Overview

  • C++不练习coding，就相当于空中楼阁，基础不扎实
  • 光吃不干，等于没吃

1.inline

在C++中，inline 关键字是一种函数修饰符，用于建议编译器在编译时将函数的代码直接插入到每个函数调用的地方，从而避免函数调用的开销。这通常用于小型函数，特别是那些包含少量指令的函数。

1.1.作用和优点

  1. 减少函数调用开销：通过避免函数调用的额外开销，可以提高程序的执行效率。
  2. 多个定义：inline 函数允许在程序中有多个定义点，这对于模板元编程特别有用。
  3. 模板：与模板结合使用时，inline 函数可以确保模板代码在每个使用点都得到实例化。

1.2.示例1：简单的内联函数

#include <iostream>

// 内联函数定义
inline int add(int a, int b) {
    return a + b;
}

int main() {
    int result = add(5, 3);
    std::cout << "Result: " << result << std::endl;
    return 0;
}

在这个示例中，add 函数被定义为内联函数。这意味着编译器将尝试在每次调用 add 时直接将其代码替换为 return a + b;。

1.3.示例2：内联成员函数

#include <iostream>

class Calculator {
public:
    // 内联成员函数
    inline int add(int a, int b) const {
        return a + b;
    }
};

int main() {
    Calculator calc;
    int result = calc.add(5, 3);
    std::cout << "Result: " << result << std::endl;
    return 0;
}

在这个示例中，Calculator 类的 add 成员函数被定义为内联函数。

1.4.示例3：内联函数与模板

#include <iostream>

// 内联模板函数
template <typename T>
inline T max(T a, T b) {
    return (a > b) ? a : b;
}

int main() {
    int i = max(3, 7);
    double d = max(6.4, 3.2);
    std::cout << "Max int: " << i << std::endl;
    std::cout << "Max double: " << d << std::endl;
    return 0;
}

在这个示例中，max 函数是一个模板内联函数，它可以用于不同的数据类型。

1.5.注意事项

  • 编译器优化：虽然你可以通过 inline 关键字请求内联，但最终是否内联由编译器决定。编译器可能会忽略内联请求，特别是对于较大的函数。
  • 定义点：对于内联函数，定义必须在包含它的每个源文件中可见。对于模板和类内的内联函数，定义通常与声明一起放在头文件中。
  • 递归函数：递归函数通常不会被内联，因为递归调用可能导致大量的代码膨胀。

inline 关键字是一个有力的工具，可以帮助优化程序性能，特别是在调用小型函数时。然而，它应该谨慎使用，以避免潜在的代码膨胀和维护问题。

2.函数综合练习题

当然，这里有一个C++函数的综合练习题，包括问题描述、代码实现和答案解析。

2.1.练习题1：计算阶乘

问题描述：
编写一个C++程序，计算并输出一个给定非负整数的阶乘。阶乘函数定义为：n! = n * (n-1) * (n-2) * … * 3 * 2 * 1。0的阶乘定义为1。

代码实现：

#include <iostream>

unsigned long long factorial(int n) {
    if (n == 0) return 1;
    unsigned long long result = 1;
    for (int i = 1; i <= n; ++i) {
        result *= i;
    }
    return result;
}

int main() {
    int number;
    std::cout << "Enter a non-negative integer: ";
    std::cin >> number;
    if (number < 0) {
        std::cout << "Factorial is not defined for negative numbers." << std::endl;
    } else {
        std::cout << "Factorial of " << number << " = " << factorial(number) << std::endl;
    }
    return 0;
}

答案解析：
这个程序定义了一个factorial函数，它使用一个循环来计算阶乘。主函数读取用户输入的非负整数，并调用factorial函数计算阶乘。

2.2.练习题2：寻找数组中的最大值和最小值

问题描述：
编写一个C++程序，找出一个整数数组中的最大值和最小值，并输出它们。

代码实现：

#include <iostream>
#include <vector>
#include <limits>

int main() {
    std::vector<int> numbers = {3, 9, 1, 4, 5, 7, 8, 2, 6};
    int max_value = std::numeric_limits<int>::min();
    int min_value = std::numeric_limits<int>::max();

    for (int num : numbers) {
        if (num > max_value) {
            max_value = num;
        }
        if (num < min_value) {
            min_value = num;
        }
    }

    std::cout << "Max value: " << max_value << std::endl;
    std::cout << "Min value: " << min_value << std::endl;

    return 0;
}

答案解析：
这个程序使用std::vector存储整数数组。它初始化两个变量max_value和min_value来存储数组中的最大值和最小值，然后遍历数组，使用条件语句来更新这两个变量的值。

2.3.练习题3：计算字符串中字符的出现次数

问题描述：
编写一个C++程序，计算并输出一个给定字符串中每个字符的出现次数。

代码实现：

#include <iostream>
#include <string>
#include <unordered_map>

int main() {
    std::string text;
    std::cout << "Enter a string: ";
    std::getline(std::cin, text);

    std::unordered_map<char, int> char_count;
    for (char c : text) {
        char_count[c]++;
    }

    std::cout << "Character counts:" << std::endl;
    for (const auto &kv : char_count) {
        std::cout << kv.first << ": " << kv.second << std::endl;
    }

    return 0;
}

答案解析：
这个程序使用std::unordered_map来存储每个字符及其出现的次数。它遍历字符串中的每个字符，并使用字符作为键来更新计数器。最后，它遍历映射并输出每个字符及其计数。

2.4.练习题4：实现一个简单的计算器

问题描述：
编写一个C++程序，实现一个简单的计算器，能够执行加、减、乘、除四种运算。

代码实现：

#include <iostream>

double add(double a, double b) {
    return a + b;
}

double subtract(double a, double b) {
    return a - b;
}

double multiply(double a, double b) {
    return a * b;
}

double divide(double a, double b) {
    if (b != 0) {
        return a / b;
    } else {
        std::cerr << "Error: Division by zero" << std::endl;
        return 0;
    }
}

int main() {
    double num1, num2;
    char operation;
    std::cout << "Enter first number: ";
    std::cin >> num1;
    std::cout << "Enter second number: ";
    std::cin >> num2;
    std::cout << "Enter operation (+, -, *, /): ";
    std::cin >> operation;

    switch (operation) {
        case '+':
            std::cout << num1 << " + " << num2 << " = " << add(num1, num2) << std::endl;
            break;
        case '-':
            std::cout << num1 << " - " << num2 << " = " << subtract(num1, num2) << std::endl;
            break;
        case '*':
            std::cout << num1 << " * " << num2 << " = " << multiply(num1, num2) << std::endl;
            break;
        case '/':
            std::cout << num1 << " / " << num2 << " = " << divide(num1, num2) << std::endl;
            break;
        default:
            std::cerr << "Invalid operation" << std::endl;
    }

    return 0;
}

答案解析：
这个程序定义了四个函数来执行基本的算术运算。主函数读取用户输入的两个数字和一个运算符，然后根据运算符调用相应的函数并输出结果。如果用户尝试除以零，程序会输出错误消息。

这些练习题覆盖了函数定义、循环、条件语句、输入输出和基本的算术运算，适合用来练习C++函数的使用。

3.前向声明

在C++中，类前向声明（forward declaration）是一种声明类的方式，而不定义类的具体内容。这在你需要引用某个类，但又不想包含定义该类的头文件时非常有用。前向声明通常用于类的指针或引用，以及当两个或多个类相互引用时。

3.1.为什么需要前向声明？

  1. 避免头文件的循环依赖：当两个或多个类相互引用时，可能会导致头文件的循环依赖问题。前向声明可以打破这种循环依赖。

  2. 减少包含头文件：如果你只需要使用类的指针或引用，而不是完整的类定义，前向声明可以减少包含头文件的需要，从而减少编译时间。

3.2.如何前向声明一个类？

使用class关键字加上类名来进行前向声明，如下所示：

class MyClass; // 前向声明

3.3.示例1：避免循环依赖

假设有两个类A和B，类A有一个类B的成员，而类B有一个类A的成员。下面是如何使用前向声明来解决这个问题：

// A.h
#ifndef A_H
#define A_H

class B; // 前向声明类B

class A {
    B* b_ptr; // 类B的指针
public:
    A(B* b);
    // ...
};

#endif // A_H

// B.h
#ifndef B_H
#define B_H

#include "A.h" // 包含A.h以获取A的前向声明

class B {
    A* a_ptr; // 类A的指针
public:
    B(A* a);
    // ...
};

#endif // B_H

在这个例子中，A.h前向声明了类B，而B.h包含了A.h以获取类A的前向声明。这样，两个类就可以相互引用，而不会直接包含对方的完整定义。

3.4.示例2：使用类指针或引用

如果你只需要使用类的指针或引用，而不需要完整的类定义，可以使用前向声明：

// ForwardDeclaration.h
#ifndef FORWARDDECLARATION_H
#define FORWARDDECLARATION_H

class ForwardClass; // 前向声明

void function(ForwardClass& obj); // 使用前向声明的类的引用

#endif // FORWARDDECLARATION_H

// ForwardDeclaration.cpp
#include "ForwardDeclaration.h"
#include "ForwardClass.h" // 实际定义

void function(ForwardClass& obj) {
    // ...
}

在这个例子中，ForwardDeclaration.h前向声明了ForwardClass，而ForwardDeclaration.cpp包含了ForwardClass.h以获取完整的类定义。

3.5.注意事项

  • 前向声明只能用于声明类的指针、引用或作为参数传递对象。如果你需要创建类的对象实例或访问其成员，就必须包含完整的类定义。

  • 前向声明不适用于需要知道类大小或布局的情况。

  • 过度使用前向声明可能会使代码难以理解和维护，因为它隐藏了类的实际定义，所以在使用时应该谨慎。

4.swap函数

在C++中，swap函数是一个非常有用的函数，它用于交换两个变量的值。C++标准库提供了std::swap函数，但你也可以自己实现一个简单的swap函数来加深理解。

以下是一个简单的swap函数实现，以及如何在程序中使用它：

4.1.示例1：自定义swap函数

#include <iostream>

// 自定义swap函数
template <typename T>
void swap(T& a, T& b) {
    T temp = a;
    a = b;
    b = temp;
}

int main() {
    int x = 10;
    int y = 20;

    std::cout << "Before swap: x = " << x << ", y = " << y << std::endl;

    swap(x, y);

    std::cout << "After swap: x = " << x << ", y = " << y << std::endl;

    return 0;
}

4.2.示例2：使用std::swap

C++标准库提供了一个std::swap函数，你可以使用它来交换两个变量的值：

#include <iostream>
#include <algorithm> // 包含std::swap

int main() {
    int x = 10;
    int y = 20;

    std::cout << "Before swap: x = " << x << ", y = " << y << std::endl;

    std::swap(x, y);

    std::cout << "After swap: x = " << x << ", y = " << y << std::endl;

    return 0;
}

4.3.示例3：交换类对象

如果你有一个类，并希望交换两个对象，你可以在你的类中提供swap成员函数：

#include <iostream>

class MyClass {
public:
    int value;

    MyClass(int val) : value(val) {}

    friend void swap(MyClass& a, MyClass& b) {
        using std::swap;
        swap(a.value, b.value);
    }
};

int main() {
    MyClass obj1(10);
    MyClass obj2(20);

    std::cout << "Before swap: obj1 = " << obj1.value << ", obj2 = " << obj2.value << std::endl;

    swap(obj1, obj2);

    std::cout << "After swap: obj1 = " << obj1.value << ", obj2 = " << obj2.value << std::endl;

    return 0;
}

在这个例子中，MyClass有一个value成员变量。我们定义了一个swap友元函数来交换两个MyClass对象的value成员。

4.4.注意事项

  • 当使用std::swap时，如果类型提供了自己的swap特化版本，编译器将使用该特化版本而不是标准库中的通用版本。

  • 自定义swap函数时，使用模板可以使其适用于任何类型的数据。

  • 在实现类时，提供一个swap成员函数或友元函数可以确保你的类对象可以正确地使用std::swap。

  • 交换操作应该尽可能地高效，避免不必要的复制，特别是对于大型对象。这就是为什么在自定义swap函数时通常使用std::swap或临时变量来减少复制次数。

关于作者

WeSiGJ
关注
专栏目录
Practical C++ Financial Programming
12-29
The book also describes many of the important problems in financial engineering that are part of the day-to-day work of financial programmers in large investment banks and hedge funds. The author has...
Practical C++ Financial Programming.pdf
06-16
many of the important problems in financial engineering that are part of the day-to-day work of financial programmers and quantitative analysts in investment banks and hedge funds. The book provides ...
C++ Practical-1 day1
wesigj的博客
09-23 1074
在实际编程中，单行注释是最常用的，因为它简洁且易于使用。的一个常见用途是处理不同的数据类型，但你知道在任何给定时间只会使用其中一种类型。当你在命令行（如终端或命令提示符）中运行一个程序时，你可以传递一些参数给程序。时，需要确保不会同时访问多个成员，因为这会导致未定义的行为。可以存储不同类型的值，但一次只能存储一个成员的值。是一种特殊的数据类型，允许在相同的内存位置存储不同的数据类型。函数是一个特殊的函数，它是每个C++程序的入口点。之前的部分会被当作注释，剩下的部分会被当作代码。
C++ Practical-1 day6
wesigj的博客
09-25 1230
在C++中，抽象类是一种不能被实例化的类，它通常作为基类使用，用于定义一个接口或规范，确保派生类遵循某些方法。抽象类通过包含至少一个纯虚函数（pure virtual function）来实现。
C++ Practical-1 day9
最新发布
wesigj的博客
09-27 1173
在C++中，自定义异常类通常是通过继承自类来实现的。自定义异常允许你为特定错误情况提供更多的上下文信息。继承：创建一个新类，继承自，并重写what()方法，该方法返回一个描述异常的字符串。提供构造函数：为你的异常类提供构造函数，允许设置错误消息和其他相关信息。抛出异常：在代码中使用throw关键字抛出你的自定义异常对象。捕获异常：使用try-catch块捕获并处理异常。// 自定义异常类private:public:// 重写 what() 方法// 一个可能抛出异常的函数try {
C++ Practical-1 day7
wesigj的博客
09-26 753
检查自赋值：首先检查是否发生自赋值，即对象赋值给自己的情况。释放现有资源：在分配新资源之前，释放对象当前持有的资源。复制资源：复制源对象的资源到当前对象。交换指针：如果使用指针管理资源，可以直接交换指针，但这种做法不适用于包含动态分配内存的复合类型。返回当前对象的引用：返回当前对象的引用，以便支持链式赋值。#include // 包含toupper函数private:char *data;public:if (str) {} else {// 重载下标运算符。
C++ Practical-1 day10
wesigj的博客
09-27 622
get()可以读取单个字符或字符数组，而getline()只能读取到对象或字符数组。get()会忽略前面的空白字符，而getline()不会忽略任何字符，包括前面的空白字符。getline()会读取换行符之前的整行数据，而get()会读取到第一个换行符为止的数据。对于像std::endl这样的流操纵符，或者像std::flush这样的函数，不需要指定变量，因为它们作用于流本身。// 输出并换行// 输出并刷新输出缓冲区return 0;在C++中，可以通过多种方式实现自定义的格式化输出。
C++ Practical-1 day5
wesigj的博客
09-25 708
在C++中，继承是面向对象编程的一个重要特性，它允许一个类（称为派生类或子类）继承另一个类（称为基类或父类）的属性和方法。在C++中，"derive"通常指的是派生类的概念，即一个类（称为派生类或子类）继承另一个类（称为基类或父类）的过程。在多重继承或简单的继承体系中，如果基类的析构函数不是虚的，那么在删除派生类对象时，基类的析构函数可能不会被调用。在C++中，当创建一个对象时，构造函数的执行顺序非常重要，尤其是当涉及到成员变量和成员对象的初始化时。，派生类的析构函数也会是虚函数。
C++ Practical-1 day8
wesigj的博客
09-26 1489
点击直达——文章总目录在C++中， 是 STL（Standard Template Library，标准模板库）中的一个关联容器，它根据键（Key）来存储和组织数据。 是基于红黑树实现的，它保证了元素的有序性，并且提供了对元素的高效访问。 1.4.注意事项 默认排序： 默认使用 对键进行排序，如果需要自定义排序，可以提供自定义比较函数。键的类型：键的类型必须支持比较运算符，且不允许修改键的值。迭代器： 提供了迭代器，可以用于遍历元素。异常安全： 的操作通常抛出异常时，容器的状态不会被破坏，可以安全地处
C++ Practical-1 day4
wesigj的博客
09-24 828
C++ Practical-1 day4
C++ Practical-1 day2
wesigj的博客
09-23 1150
/ 定义一个结构体，用于表示点int x;int y;// 创建一个点Point p;p.x = 10;p.y = 20;// 输出点的坐标// 创建另一个点// 列表初始化// 修改并输出点的坐标return 0;C++11允许在结构体中定义函数，这使得结构体可以包含方法。#include // 用于sqrt函数// 定义一个结构体，用于表示点，并包含一个方法int x, y;// 方法：计算点到原点的距离return 0;
神书-C++ STL源码解析-高清完整版
12-28
神书-STL实现原理，对于强化数据结构-算法的程序员必备、必读书籍。The Best-Selling Programmer Resource–Now Updated for ... A comprehensive index will support the C++ programmer in his/her day-to-day life.
c++ stringstream ss()
热门推荐
wesigj的博客
10-08 1万+
定义了三个类：istringstream、ostringstream 和 stringstream，分别用来进行流的输入、输出和输入输出操作。本文以 stringstream 为主，介绍流的输入和输出操作。 主要用来进行数据类型转换，由于 使用 string 对象来代替字符数组（snprintf方式），就避免缓冲区溢出的危险；而且，因为传入参数和目标对象的类型会被自动推导出来，所以不存在错误的格式化符的问题。简单说，相比c库的数据类型转换而言， 更加安全、自动和直接。 一、从string对象str中读.
C++ getline函数用法详解
wesigj的博客
10-08 1万+
(1) istream& getline (istream& is, string& str, char delim); istream& getline (istream&& is, string& str, char delim); (2) istream& getline (istream& is, string& str); istream& getline (istream&& is, string& str); Get line from stream into string Extra
C++ to_string()函数
wesigj的博客
05-10 6392
系列文章目录 文章目录系列文章目录前言一、C++ to_string()函数详解二、example总结 前言 http://www.cplusplus.com/reference/string/to_string/ 一、C++ to_string()函数详解 std::to_string string to_string (int val); string to_string (long val); string to_string (long long val); string to_st
【C++】一文读懂多重条件判断、多条件判断
wesigj的博客
05-30 4818
系列文章目录 文章目录系列文章目录前言一、if else1.1 优点：1.2 缺点：二、switch case2.1 优点：2.2 缺点：总结 前言 多重条件判断、多条件判断是每一个程序员都无法绕过的障碍，在C/C++的世界，你可以用if else、 switch case等等来进行条件判断。而优化多重条件判断的方法有很多，例如键值对匹配、 switch、 提前返回、设计模式，设计模式中有策略模式， 表模式等等。 一、if else 1.1 优点： 1、灵活性强 当业务需要变更时，if el
C++ empty()函数
wesigj的博客
10-06 3478
empty() NULL空就返回1，其他返回0 bool empty() const noexcept; Test if string is empty Returns whether the string is empty (i.e. whether its length is 0). This function does not modify the value of the string in any way. To clear the content of a string, see string:
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

WeSiGJ

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

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

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

打赏作者

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

抵扣说明：

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

余额充值