C++程序阅读常见题型

已于 2024-10-19 12:38:34 修改
阅读量565 收藏 17
点赞数 3
文章标签： c++
于 2024-10-19 11:53:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Chowhound_G/article/details/143073442
版权

1.逻辑运算符优先级

#include <iostream>
using namespace std;

int main() {
    int a = -1, b = 2, c = 3;
    int f1, f2, f3;

    // f1 = (a++ && b || (c++))
    // a++: 由于 a 是 -1 (true)，执行后 a 的值变为 0，但返回值是 -1。
    // a++ && b: 由于 a++ 为 true，b 为 2 (true)，因此 "a++ && b" 为 true (1)。
    // 后续的 c++ 没有执行，因为 "a++ && b" 已经为 true，整个表达式的值已经可以确定为 true。
    f1 = (a++ && b || (c++));
    cout << f1 << endl;  // 输出 f1 = 1 (true)

    // f2 = --a || b++ && c++;
    // --a: 首先将 a 减 1，a 的值变为 -1 (true)，因此 --a 为 true。
    // 由于 --a 为 true，后续的 "b++ && c++" 不会执行。
    // b 和 c 的值保持不变（b = 2, c = 3）。
    f2 = --a || b++ && c++; 
    cout << f2 << endl;  // 输出 f2 = 1 (true)

    // 重置 a 的值为 0。
    a = 0;

    // f3 = a++ && b++ && c++;
    // a++: 首先将 a 的值从 0 增加到 1，但 a++ 返回的值是 0 (false)。
    // 由于 a++ 为 false，后续的 b++ 和 c++ 不会执行。
    f3 = a++ && b++ && c++;  // f3 = 0 (false)
    cout << f3 << endl;  // 输出 f3 = 0

    // 输出 a, b, c 的当前值。
    // a = 1 (因为 a++ 已执行)
    // b = 2 (没有变化，因为 b++ 没有执行)
    // c = 3 (没有变化，因为 c++ 没有执行)
    cout << a << " " << b << " " << c << endl;  // 输出 a = 1, b = 2, c = 3

    return 0;
}

在C++中，逻辑运算符的优先级如下：

  1. 逻辑非 (!) 优先级最高。
  2. 逻辑与 (&&) 的优先级高于 逻辑或 (||)。

具体优先级顺序为：

  • 逻辑非 (!)
  • 逻辑与 (&&)
  • 逻辑或 (||)

因此，逻辑与的优先级高于逻辑或。例如：

bool result = true || false && false;

按照优先级顺序，等价于：

bool result = true || (false && false);

结果为 true。

如果你想改变默认的优先级，可以使用括号强制指定计算顺序。

cout << !++n + 3 << endl;

操作符优先级：

  1. 前置自增运算符 ++：最高优先级，首先执行。
  2. 逻辑非运算符 !：其次执行。
  3. 加法运算符 +：最后执行。

2.ASCII 隐式转换

(21年阅读题1)

#include<iostream>
using namespace std;

int main() {
    char a = 'a';  // 变量 a 被初始化为字符 'a'，ASCII 值为 97。
    cout << ++a << endl;  // 前置自增，a 变为 'b'（ASCII 98），输出 'b'。
    cout << a + 1 << endl;  // a 是 'b'（ASCII 98），98+1 = 99，输出 99（整数）。
    int b = 3.14;  // 3.14 是浮点数，但被转换为 int，只保留整数部分，b = 3。
    b /= 3;  // b = 3 / 3，整数除法，结果为 1，b = 1。
    cout << b / 3 << endl;  // b 是 1，1 / 3 进行整数除法，结果为 0，输出 0。
    bool c = a && b;  // a 是 'b'（98，非零），b 是 1（非零），因此 a && b 为 true，c = true。
    cout << (c || a ? b * 3 : a % 5) << endl;  
    // c 是 true，a 也是非零（true），所以 c || a 为 true，选择 b * 3。
    // b 是 1，所以 b * 3 = 3，输出 3。
    return 0;
}

输出 c 时，虽然它是 true，但 cout 输出 bool 类型变量时，会将 true 作为 1 输出。

3.字符串 指针

#include<iostream>
using namespace std;

int main() {
    char S[] = "Mucky";  // 定义字符数组 S，内容为 "Mucky"。
    char *p = S, *q = &S[2];  // 指针 p 指向字符串 S 的首字符，指针 q 指向 S[2] 位置，即 'c'。

    cout << S << endl;  // 输出整个字符串 S，输出结果为 "Mucky"。

    cout << --*p << endl;  
    // *p 是指针 p 所指向的内容，也就是 S[0]，即 'M'。
    // --*p 是先将 'M' 自减 1，'M' 的 ASCII 值是 77，减 1 后变为 76，对应的字符是 'L'。
    // 所以这行输出 'L'，并且字符串 S 变为 "Lucky"（第一个字母被修改为 'L'）。

    cout << S[1] << endl;  
    // S[1] 是字符 'u'，所以输出 'u'。

    cout << S + 3 << endl;  
    // S + 3 是指向字符串 S 从索引 3 开始的地址。
    // S[3] 是 'k'，因此会输出从 S[3] 开始的部分字符串 "ky"。

    return 0;
}

4.继承与构造函数调用顺序

#include<iostream>
using namespace std;

class A {
    public:
        // 构造函数 A 接受一个 double 类型的参数 x，默认值为 1，输出 x。
        A (double x = 1) {
            cout << x << endl;  // 输出传入的 x 值。
        }
};

class B : public A {
    public:
        // 构造函数 B 接受两个参数 x 和 y，其中 y 有默认值 1。
        // 构造函数 B 在初始化时，显式调用了基类 A 的构造函数 A(y)，然后输出 x。
        B (double x, double y = 1) : A(y) {
            cout << x << endl;  // 输出传入的 x 值。
        }
};

int main() {
    // 创建对象 b1，调用 B(1)。这里 x = 1，y 使用默认值 1。
    B b1 = B(1);
    // 调用 B(1) 时，先调用 B 的构造函数，基类 A 的构造函数 A(1) 被调用并输出 1。
    // 然后继续执行 B 的构造函数，输出 x = 1。
    
    // 创建对象 b2，调用 B(3, 2)。这里 x = 3，y = 2。
    B b2 = B(3, 2);
    // 调用 B(3, 2) 时，先调用 B 的构造函数，基类 A 的构造函数 A(2) 被调用并输出 2。
    // 然后继续执行 B 的构造函数，输出 x = 3。

    return 0;
}

5.析构函数调用顺序

#include<iostream>
using namespace std;

class A{
    public:
        // 类A的构造函数
        A(int a){
            this->a = a;        // 将传入的参数a赋值给成员变量a，此时成员变量a = 2
            initaa();           // 调用initaa()方法，修改成员变量a的值
            cout << "A" << a << endl; // 注意，这里的a是构造函数的形参a，不是成员变量a
        }
        ~A(){
            cout << "~A" << endl;   // 类A的析构函数，输出“~A”
        }
        int a;  // 公有成员变量a
    private: 
        void initaa(){
            a *= 2;     // 将成员变量a的值乘以2，此时a = 4
            aa = a * a; // 计算aa为a的平方，aa = 16
        }
        int aa; // 私有成员变量aa
};

class B : public A {
    public:
        // 类B的构造函数，默认参数y=3
        B(int x, int y=3) : A(y) {
            // 基类A的构造函数已执行完毕
            cout << "B" << a << endl; // 这里的a是从A继承的成员变量a，值为4
        }
        ~B() {
            cout << "~B" << endl; // 类B的析构函数，输出“~B”
        }
};

int main(){
    // 创建B类的对象b2，传入参数x=3, y=2
    B b2 = B(3, 2);
    return 0;
}

调用函数后会析构

在 showX(objX) 中，objX 被按值传递，这意味着会创建一个临时副本，因此会多一次 X 类的构造函数和析构函数调用。

#include <iostream>
using namespace std;

class X {
public:
    X() { cout << "X constructor" << endl; }
    ~X() { cout << "X destructor" << endl; }
};

class Y {
public:
    Y() { cout << "Y constructor" << endl; }
    ~Y() { cout << "Y destructor" << endl; }

    void showX(X obj) {
        cout << "Inside showX" << endl;
    }
};

int main() {
    cout << "Start" << endl;
    
    Y objY;
    X objX;

    objY.showX(objX);
    
    cout << "End" << endl;

    return 0;
}

6.快速排序

#include <iostream>
using namespace std;

// 函数声明
int partition(int arr[], int low, int high);
void quickSort(int arr[], int low, int high);
void printArray(int arr[], int size);

// 主函数
int main() {
    int arr[] = {12, 4, 9, 3, 15, 7, 8};
    int n = sizeof(arr) / sizeof(arr[0]);
    
    cout << "原始数组: ";
    printArray(arr, n);
    
    quickSort(arr, 0, n - 1);
    
    cout << "排序后的数组: ";
    printArray(arr, n);
    
    return 0;
}

// 快速排序算法
void quickSort(int arr[], int low, int high) {
    if (low < high) {
        // pi 是分区点，arr[pi] 已经排好序
        int pi = partition(arr, low, high);
        
        // 分别递归排序左右两部分
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}

// 分区函数
int partition(int arr[], int low, int high) {
    int pivot = arr[high]; // 选择最后一个元素为基准
    int i = (low - 1); // 小于 pivot 的元素的索引

    for (int j = low; j <= high - 1; j++) {
        // 如果当前元素小于或等于 pivot
        if (arr[j] <= pivot) {
            i++; // 增加小于 pivot 的元素的索引
            swap(arr[i], arr[j]);
        }
    }
    swap(arr[i + 1], arr[high]);
    return (i + 1);
}

// 打印数组函数
void printArray(int arr[], int size) {
    for (int i = 0; i < size; i++)
        cout << arr[i] << " ";
    cout << endl;
}

7.字符串计算

#include <iostream>
#include <string>

enum Month {
    JAN = 1, FEB, MAR, APR, MAY, JUN, 
    JUL, AUG, SEP, OCT, NOV, DEC
};

// 将月份的三字符缩写转换为对应的枚举值
int getMonthValue(const std::string& month) {
    if (month == "JAN") return JAN;
    if (month == "FEB") return FEB;
    if (month == "MAR") return MAR;
    if (month == "APR") return APR;
    if (month == "MAY") return MAY;
    if (month == "JUN") return JUN;
    if (month == "JUL") return JUL;
    if (month == "AUG") return AUG;
    if (month == "SEP") return SEP;
    if (month == "OCT") return OCT;
    if (month == "NOV") return NOV;
    if (month == "DEC") return DEC;
    return 0;  // 若没有匹配到，返回0
}

// 计算字符串中每个字符数字的和
int sumOfDigits(const std::string& str) {
    int sum = 0;
    for (char ch : str) {
        if (isdigit(ch)) {
            sum += ch - '0';  // 将字符转换为数字并累加
        }
    }
    return sum;
}

int main() {
    std::string input;
    
    while (true) {
        std::getline(std::cin, input);
        
        // 处理输入结束符 #
        if (input == "#") break;
        
        // 提取日期格式中的各个部分
        std::string day = input.substr(0, 2);
        std::string month = input.substr(3, 3);
        std::string year = input.substr(7, 4);
        
        // 计算各部分数字之和
        int daySum = sumOfDigits(day);
        int yearSum = sumOfDigits(year);
        int monthValue = getMonthValue(month);
        
        int totalSum = daySum + monthValue + yearSum;
        
        // 输出结果
        std::cout << totalSum << std::endl;
    }

    return 0;
}

8.switch和static_cast

#include <iostream>
#include <string>

using namespace std;

// 定义第一个函数，带有一个默认参数 "sun" 的函数
void func(string sun="***"){
    // for 循环，循环三次，打印 sun
    for(int i=0;i<3;i++){
        cout << sun;
    }
    cout << endl; // 换行
}

// 定义第二个函数，带有默认参数 'a'
void func(int n, char a='a'){
    // 打印字符 'a' 加上 n（整数偏移的 ASCII 值）
    cout << static_cast<char>(a+n) << endl;
}

int main() {
    // 定义一个字符串变量 sun
    string sun = "*b*c*d";
    
    // for 循环，i 从 5 开始，每次自增 1，直到 i 等于 n，即 10
    for(int i=5; i++<n;){ // 相当于 i = 6 开始
        cout << i << endl; // 输出当前的 i 值
        
        // 根据 i % 3 的结果选择不同的 case
        switch(i%3){
            // i%3 == 0 时
            case 0: 
                func(); // 调用 func()，输出 "*********"
                // 注意：没有 break，因此会继续执行下一个 case

            // i%3 == 1 时
            case 1: 
                cout << "case 1:"; // 输出 "case 1:"
                func(i%3); // i%3 == 1 时调用 func(1)，打印 'b'
                break; // 结束 switch

            // i%3 == 2 时
            case 2: 
                cout << "case 2:"; // 输出 "case 2:"
                // 调用带有两个参数的 func 函数，n-9 == 1，sun[(i%2+1)*2-1] 对应 sun 字符串的某个字符
                func(n-9, sun[(i%2+1)*2-1]); 
                // sun[(i%2+1)*2-1] 计算解释：
                // i%2 == 0 时，(i%2+1)*2-1 == 1，输出 sun[1]，即 'b'
                // i%2 == 1 时，(i%2+1)*2-1 == 3，输出 sun[3]，即 'c'
                break; // 结束 switch
        }
    }
    return 0;
}

9.指针

int main() {
    // 初始化一个二维字符数组，包含多个字符串
    char s[][20] = {"b++", "python", "bplusplus", "basic"};
    char (*p)[20]; // 定义一个指向字符数组的指针
    
    // 输出 s[0] 的内容，即 "b++"
    cout << s[0] << endl; // 输出：b++
    
    // *(s + 1) 等价于 s[1]，即 "python"
    cout << *(s + 1) << endl; // 输出：python
    
    p = s + 2; // p 指向 s[2]，即 "bplusplus"
    
    // (*p)[0] 等价于 s[2][0]，即 'b'，通过 ++(*p)[0] 将 'b' 自增为 'c'
    cout << ++(*p)[0]; // 输出：c
    
    // *s 等价于 s[0]，*s + 1 则指向 s[0] 的第二个字符，即 '+'
    cout << *s + 1 << endl; // 输出：++ （从 s[0] 的第二个字符 '+' 开始）
    
    return 0;
}

10.虚函数

#include <iostream>
using namespace std;

class A{
    public:
    virtual void func(){ cout<<"A"<<endl;}
};
class B:public A{
    public:
    void func(){ cout<<"B"<<endl;}
};
class C:public B{
    public:
    void func(){cout<<"C"<<endl;}
    private:
        int m;
};
int main() {
    A *a1 = new A();
    a1->func();//A
    A *a2 = new B();
    a2->func();//B
    A *a3 = new C();
    a3->func();//C
    C *c = new C();
    c->func();//C
    return 0;
}

11.函数递归

int fun(int m, int n)
{
    if (m == 0)
        return n + 1;
    else if (m > 0 && n == 0)
        return fun(m - 1, fun(m, n - 1));
    else if (m > 0 && n > 0)
        return fun(m - 1, fun(m - 1, n - 1));
}
int main()
{
    cout << fun(3, 4) << endl;//5
    cout << fun(2, 2) << endl;//3
    return 0;
}

12.类的对象递归调用

#include <iostream>
using namespace std;

class Counter {
public:
    Counter(int n) : num(n) { 
        cout << "Constructor called for " << num << endl; 
    }
    
    ~Counter() { 
        cout << "Destructor called for " << num << endl; 
    }

    void countDown() {
        if (num > 0) {
            Counter temp(num - 1);  // 创建一个临时对象
            temp.countDown();       // 递归调用
        }
        cout << "Counting: " << num << endl;
    }

private:
    int num;
};

int main() {
    Counter counter(3);  // 创建 Counter 对象，num 初始为 3
    counter.countDown();  // 调用递归方法
    return 0;
}

输出结果:

Constructor called for 3
Constructor called for 2
Constructor called for 1
Constructor called for 0
Counting: 0
Destructor called for 0
Counting: 1
Destructor called for 1
Counting: 2
Destructor called for 2
Counting: 3
Destructor called for 3
  • 每次递归调用都会创建一个新的 Counter 对象，并调用构造函数输出相关信息。
  • 当递归终止时（num = 0），开始回溯，在回溯的过程中依次输出 Counting: num，并销毁临时对象（调用析构函数）。

13.左移

左移一位*2 [<<]

右移一位/2 [>>]

#include <iostream>
using namespace std;

int main() {
    int x = 5, y = -3, z = 16;
    // 左移操作，将 x 左移 1 位，相当于乘以 2
    int a = x << 1;
    // 右移操作，将 y 右移 2 位，相当于除以 4（对于负数右移，符号位会保持不变）
    int b = y >> 2;
    // 将 z 左移 2 位，相当于乘以 4
    int c = z << 2;
    // 输出 a, b, c 的结果
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    cout << "c = " << c << endl;

    return 0;
}
Chowhound_G
关注
C语言程序设计试题及答案解析
04-15
C语言程序设计试题及答案解析，帮助初学者快速掌握C语言
C/C++语言经典、实用、趣味程序设计编程百例精解
吾尝终日而思矣，不如须臾之所学也
12-10 2万+
C/C++语言经典、实用、趣味程序设计编程百例精解（1）  1.绘制余弦曲线 在屏幕上用“*”显示0~360度的余弦函数cos(x)曲线 *问题分析与算法设计 如果在程序中使用数组，这个问题十分简单。但若规定不能使用数组，问题就变得不容易了。 关键在于余弦曲线在0~360度的区间内，一行中要显示两个点，而对一般的显示器来说，只能按行输出，即：输出第一行信息后，只能向下一行输出，不能再
C++程序设计带答案
workflower的博客
12-04 1039
3、下面关于break语句的描述中，不正确的是( D )。C、break语句可以在switch语句中出现多次。B、break语句可以在for循环语句中出现多次。1、下面程序的运行结果为（ C ）。2、下列选项，不正确的是（ B ）。D、break语句可用于if条件判断语句内。A、break可以用于循环体内。程序设计的三种基本结构分别是（多分支结构的实现可以通过（执行程序之后的输出结果为（、下面程序的运行结果是。、当执行以下程序段时（语言的跳转语句中，对于。语句执行循环的次数是（
第九周项目一 阅读程序，写出程序运行结果并理解（1）
Scotland Yard
04-23 2268
/*copyright(c)2016.烟台大学计算机学院 * All rights reserved, * 文件名称：text.Cpp * 作者：舒文超 * 完成日期：2016年4月17日 * 版本号：vc++6.0 * * 问题描述:阅读下面程序，写出运行结果并理解 */ #include using namespace std; class A {
【C++】程序阅读题。
eusbjwsv的博客
09-01 2848
一. #include<iostream> using namespace std; class basic{ private: int a,b; public: basic(int i,int j) { a=i; b=j; } void add(int x,int y) { a+=x; b+=y; } void print() { cout<<"a="<<a<<
C++程序的阅读
ruixj的专栏
04-11 1309
C++中的类型转换操作符的重载      C++中类对象定义了类型转换操作符后，表达式的含义就要仔细分析。任何一步都有可能导致类型转换函数的调用。这是C和C++很大的不同。 C++中全局变量     对于C++中全局对象变量，其构造函数的调用先于main，实在可执行文件被装载时就调用的，处于ELF中的.init section.     C语言中，全局变量没有构造函数。 
《C++程序设计》考试-阅读程序题.pdf
09-26
《C++程序设计》考试-阅读程序题.pdf
经典C++笔试题目--100(程序阅读题(62-90))
xiangjai的专栏
08-25 1万+
程序阅读题(62-90) 62、main 函数执行以前，还会执行什么代码？ 【参考答案】 全局对象的构造函数会在main 函数之前执行。 63、 There are two int variables: a and b, don’t use “if”, “? :”, “switch”or other judgement statements, find out
C++程序阅读题 面试题目29例
2401_83470102的博客
03-22 955
*这里是考对变量越界理解，同时....，所以，999...应该改为 ~((int)0),也就是整数中0取反考对变量块作用域的理解，这里的i，在循环后就不存在了*//*主要是考看对C++的基础知识是否了解这里的int nArrLength(400)是对整数的定义，当然，明名上有问题，这里是故意这样的，就是说，不管是指向何种对象的指针变量，它们占用内存的字节数都是一样的，并且要足够把程序中所能用到的最大地址表示出来（通常是一个机器字长）。C错误，左侧不是一个有效变量，不能赋值，可改为 (++a) += a;
大规模C++程序设计_大规模C++程序设计_betweenyeu_
09-30
《大规模C++程序设计》是一本深度探讨C++在大型项目中的应用与实践的书籍，由betweenyeu撰写。本书旨在帮助开发者掌握在复杂工程环境下编写高效、可维护且易于扩展的C++代码的关键技巧。以下是对书中核心知识点的...
NOIP近10年真题阅读程序写结果答案及详细解释C++
11-28
NOIP近10年真题阅读程序写结果答案及详细解释C++NOIP近10年真题阅读程序写结果答案及详细解释C++
C++编程练习题大全(带答案).pdf
03-06
409页C++练习题，涵盖了入门习题，提高习题，同时也包含了大量基础算法及一些链表、队列等算法习题，方便在入门C++的同时，对一些算法进行了解。
C++ 程序设计题库
09-09
1.绘制余弦曲线 3 2.绘制余弦曲线和直线 4 3.绘制圆 5 4.歌星大奖赛 5 5.求最大数 6 6.高次方数的尾数 7 7.阶乘尾数零的个数 8 8.借书方案知多少 9 9.杨辉三角形 9 10.数制转换 11 11.打鱼还是晒网 12 12.抓交通肇事犯 14 13.该存多少钱 14 14.怎样存钱利最大 15 15.捕鱼和分鱼 17 16.出售金鱼 18 17.平分七筐鱼 19 18.有限5位数 20 ........
C++编程练习题大全(带答案)
04-26
本资源为C++学者入门实用资料，C++编程练习题大全(带答案)，转自网络，知识共享，版权归原创所有
C++编程练习题及答案
03-26
C++编程练习题及答案
C++程序启动报错和启动失败的常见原因分析与排查经验总结
最新发布
dvlinker的技术专栏
12-24 2万+
本文对引发C++程序启动报错或启动失败的常见原因及相关排查办法进行了详细地总结，并给出具体的项目问题实战分析实例。相关的总结及实战分析案例均来自于项目实战，有很强的实战参考价值。
C++程序使用 STL 容器发生异常的常见原因分析与总结
热门推荐
dvlinker的技术专栏
03-24 4万+
使用 STL 容器发生异常的常见原因分析与总结
C++程序发生闪退且没生成dump文件问题的排查经验总结与分享
dvlinker的技术专栏
10-14 2万+
本文详细讲述了C++程序发生闪退且没有生成dump这类问题的场景及排查方法，并给出了相关实战问题分析实例，有一定的实战参考价值。
C++补全程序常见题型
12-09
C++补全程序是一种常见的编程题型，主要用于考察学生对C++语言的理解和编程能力。这类题型通常会给出一段不完整的代码，要求考生根据题意补全代码，使其能够正确运行。以下是一些常见的C++补全程序题型： 1. **函数...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值