精华内容
下载资源
问答
  • 1,课程简介与简单程序设计 2,日期处理与高精度计算 3,字符串处理 4,指针与链表 5,枚举与搜索 6,7, 递归与动态规划 8,9,和对象 10,继承和多态 11,string与字符串流处理 12,文件处理 13,-16,标准...
  • 北京科技大学小学期计算机游戏设计实习,实习报告之黄金矿工,内容详实,内附代码。
  • 北京大学:C++程序设计 课堂笔记

    千次阅读 多人点赞 2019-03-18 22:19:55
    北京大学程序设计与算法系列之C++程序设计,视频:Coursera、哔哩哔哩 程序设计与算法:C++程序设计介绍C++程序设计P3 01 :函数指针P4 02 命令行参数P5 03 位运算`&...

    介绍

    北京大学程序设计与算法系列之C++程序设计,视频:Coursera、哔哩哔哩

    说明

    本课堂笔记目的是方便自己和大家复习以及查阅使用,所以课件内容偏多,请见谅。如有修改意见,欢迎大家提出。

    程序设计与算法:C++程序设计

    C++程序设计

    P3 01 :函数指针

    1. 定义: 类型名( 指针变量名)(参数类型1, 参数类型2, …)*
      例如:int (*pf)(int, char)
    2. 使用:函数指针名(实参表)
      例如:pf = PrintMin; pf(x, y);
    3. 应用:C快速排序任意类型数组:qsort库函数
      void qsort(void *base, int nelem, unsigned int width, int(* pfCompare)(const void *, const void *)
      函数需要以下四个参数:
      1. 数组的起始地址:base
      2. 数组元素个数:nelem
      3. 数组元素大小:width
      4. 排序前后规则:int(* pfCompare)(a, b)
        其中,返回值包含以下三种情况:
        • 负整数:a在前,b在后;
        • 0:哪个参数在前都可以;
        • 正整数:a在后, b在前。
    #include <strio.h>
    #include <stdlib.h>
    
    int MyCompare(const void * elem1, const void * elem2) {
        unsigned int * p1, * p2;
        p1 = (unsigned int *) elem1;    // "* elem1" 非法
        p2 = (unsigned int *) elem2;    // "* elem2" 非法
        return (*p1 % 10) - (*p2 % 10)
    }
    #define NUM 5
    int main() {
        unsigned int an[NUM] = {8, 123, 11, 10, 4};
        qsort(an, NUM, sizeof(unsigned int), MyCompare);
        for(int i = 0; i < NUM; i++) {
            printf("%d", an[i])     // output: 10 11 123 4 8
        }
        return 0;
    }
    

    P4 02 命令行参数

    命令行程序示例:

    > notepad sample.txt
    > copy file1.txt file2.txt
    

    实现方式:

    int main(int argc, char * argv[])
    {
    	...
    }
    

    其中,argc:命令行参数的个数。由于可执行程序本身的文件名也计算在内,故argc大于等于1。而argv[]是一个指针数组,argv[0]:可执行文件名;argv[1]:第2个命令行参数;以此类推。
    注:某一命令行参数如果有空格,可用双引号括起。

    #include <stdio.h>
    int main(int argc, char* argv[]) {
        for (int i = 0; i < argc; i++) {
            print("%s\n", argv[i]);
        }
        return 0;
    }
    
    // 以上编译成sample.exe, 控制台执行:
    // sample para1 para2 s. txt 5 "hello world"
    

    P5 03 位运算

    位运算符包括:

    1. &:按位与
    2. |:按位或
    3. ^:按位异或
    4. :按位非(取反)
    5. <<:按位左移
    6. >>:按位右移

    &:按位与运算

    用途:

    1. 变量中的某位置清0,且同时保留其他位不变。
      例如:int型变量n,使其低8位置0,其他位不变:
      n = n & 0xffffff00;
      或者:n &= 0xffffff00;
      nshort型(16位),则n &= 0xff00
    2. 获取变量中的某一位。
      例如:判断n第7位是否为1(从右往左,从0开始):
      判断n & 0x80是否等于0x80,因为0x80 == 1000 0000

    |:按位或运算

    用途:

    1. 变量中的某位置置1,且同时保留其他位不变。
      例如:int型变量n,使其低8位置1,其他位不变:
      n |= 0xff;

    ^:按位异或运算

    用途:

    1. 变量中的某位置取反,且同时保留其他位不变。
      例如:int型变量n,使其低8位取反,其他位不变:
      n ^= 0xff;
      特点:由a ^ b = c可得:c ^ b = a以及c ^ a = b
      因此按位异或运算可用作简单的加密和解密。
    2. 不通过临时变量,交换两个变量的值。
    int a = 5, b = 7;
    a = a ^ b;
    b = b ^ a;
    a = a ^ b;
    

    ~:按位非运算

    用途:pass.

    <<:按位左移运算

    含义:a << b:将a按位左移b位。
    性质:高位丢弃,低位补0;a的值不会因此改变。
    左移n位,相当于乘以2n。但是左移运算比乘法运算快得多。

    >>:按位右移运算

    含义:a >> b:将a按位右移b位。
    性质:低位丢弃,高位补0;a的值不会因此改变。

    有符号数,如long, int, short, char 类型,符号位(最高位)一起移动。大多数编译器规定,如果原符号位为1,则右移时高位就补充1;原符号位为0,则右移时高位就补充0。

    右移n位,相当于除以2n,并将结果往小里取整。例如

    -25 >> 4 = -2
    -2 >> 4 = -1
    18 >> 4 = 1

    注:负数转化成二进制:以补码形式表示,即先按正数转换,然后取反加1。

    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

    P6 04 引用

    形式:类型名 & 引用名 = 某个变量名
    例如:

    int n = 4;
    int & r = n;   // r 引用了 n, r 类型是 int &
    

    含义:某个变量的引用,等价于这个变量,相当该变量的一个别名。

    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

    P7 05 const 关键字和常量

    • 要点:
      1. 避免使用define, 因为const有类型方便检查。
    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述
        在这里插入图片描述在这里插入图片描述错误1:不可通过常量指针修改其指向的内容;错误2:strcpy()的第一个参数类型为char *,而pconst char *,不能将const char *类型的指针赋给char *类型。
        在这里插入图片描述

    P8 06 动态内存分配

    • 要点:
      1. C语言:通过malloc分配内存。C++:new关键字实现动态分配内存。
      2. 分配变量:P = new T;,其中T为任意类型名。
      3. 分配数组:P = new T[N];
    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

    P9 07 内联函数和重载函数

    内联函数:不用栈调用,直接贴到主程序。
    优点:加快程序运行。
    缺点:导致可执行程序体积过大。

    重载函数:名字相同,参数表不同。

    • 课件
      • 如下:在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

    P10 08 函数缺省参数

    • 课件
      • 如下:
        在这里插入图片描述
        在这里插入图片描述

    P11 09 面向对象程序设计

    • 结构化程序设计的弊端
    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述
        在这里插入图片描述
      • 面向对象程序设计
        含义:,相当于模板
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

    P12 10 面向对象语言发展历程

    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述

    P13 11 从客观事物抽象出类的例子

    • 实例化对象
    • 类成员的访问:
    1. 对象名.成员名
    2. 指针->成员名
    3. 引用名.成员名
    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述实例化过程:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述注:函数形参里的 &r 去掉不影响结果输出,但效率低。
        在这里插入图片描述
        在这里插入图片描述

    P14 12 类成员的可访问范围

    • 要点:

      1. 缺省类型的成员为私有成员,即未明确可访问类型的变量。
      2. 类的公有成员函数内部的私有变量是可以访问到的。
      3. 类的私有成员变量只能由类的成员函数访问。原因之一:方便修改。
    • 课件

      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

    P15 01 内联成员函数和重载成员函数

    • 要点:

      1. 内联函数的设计目的:单独一个函数语句少的情况下,反复调用,开销大。
      2. 参数缺省的目的:提高程序的可扩展性。添加新的函数时,不需要的参数可直接用默认值。
    • 课件

      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

    P16 02 构造函数(constructor)

    • 要点:
      1. 构造函数的目的:对象初始化
      2. 它不分配存储空间,而是在已经分配空间之后做初始化的工作。例如:盖房子,房子是一个对象,构造函数仅仅是在房子盖好之后进行装修。
      3. 对象生成时一定会调用构造函数。
      4. 对象一定要初始化在使用。
    • 初始化列表
      构造函数的执行可以分成两个阶段:初始化、计算。初始化列表直接在初始化阶段赋初值,从而省去了调用默认构造函数的过程。必须要用初始化列表的三种情况:常量成员(只能初始化不能赋值)、引用类型(必须在定义的时候初始化)、没有默认构造函数的类类型。参考
    • 课件:
      • 如下
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述注:pArray[3]是 指针数组,不是对象数组,它的每一个元素都是指针,可以不初始化,因此,它不会引发对象生成。指针只表示指示作用,所以不会导致指示的对象生成构造函数。此时,对前两个指针初始化,new的返回值类型为Test *

    P17 03 复制构造函数

    • 要点:
      1. 把某一对象C1的成员变量复制到另一对象C2,即复制品
      2. 复制构造函数被调用的三种方式:
        1. 一个对象去初始化另一个对象;
        2. 函数参数是类A的对象
        3. 函数返回值是类A的对象
    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述注:C++的标准不允许复制构造函数传值参数,否则会编译出错。因为是传值参数,我们把形参复制到实参会调用复制构造函数。如果允许复制构造函数传值,就会在复制构造函数内调用复制构造函数,就会形成永无休止的递归调用从而导致栈溢出。(来自:剑指offer)
        在这里插入图片描述在这里插入图片描述
        在这里插入图片描述注:复制构造函数的作用:复制一个对象的成员变量给另一对象。
      void Func(Complex1 a1){}		//	会调用复制构造函数,如同值传递
      void Func(Complex1 & a1){}		//	对象引用,不会调用复制构造函数,如同地址传递
      void Func(const Complex1 a1){}	//	会调用复制构造函数,不允许修改。
      void Func(const Complex1 & a1){}//	常对象引用,不会调用复制构造函数,不允许修改,如同地址传递
      
      博客C++构造函数详解(复制构造函数)是这么说的:复制构造函数参数为类对象本身的引用,用于根据一个已存在的对象复制出一个新的该类的对象,一般在函数中会将已存在对象的数据成员的值复制一份到新创建的对象中。 在这里插入图片描述在这里插入图片描述注:(来自B站评论)不管是返回一个类对象还是传入类对象作为参数,这个类对象不再是类对象,而是调用了以这个类对象作为参数的复制构造函数。即非引用类型的对象作为形参或是函数返回值时,在调用函数过程都会初始化同类型的对象,因此都会调用复制构造函数。
      在这里插入图片描述

    P18 04 类型转换构造函数

    • 要点:
      1. 适用于解决两边类型不一致的情况。
    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述注:Complex c2 = 9;中的等号=代表初始化,并非赋值。在调用类型转换构造函数时不会生成临时对象。而c1 = 9;为赋值语句,等号两端为不同类型,相当于以9作为实参调用类型转换构造函数Complex (int i),生成一个临时Complex对象赋值给c1

    P19 05 析构函数

    • 要点:
      1. 在对象销毁时调用,与构造函数相对应。
    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述
        注:构造函数和析构函数的调用时机
      1. d4 = 6;:调用类型转换构造函数,生成临时对象。
      2. {}:代表作用域,相当于生命周期。
      3. 静态变量在整个函数结束时消亡。
      4. 析构函数释放顺序:局部变量->静态变量->全局变量
        在这里插入图片描述

    P20 06 静态成员变量和静态成员函数

    • 要点:
      1. 静态成员变量和函数,相当于该类全局变量和函数。
      2. 静态成员函数中不能包含非静态变量和函数。
      3. 静态成员,实际上不放在成员内部,而是放在所有成员的外面,被所有对象共享。即静态成员只与该类相关,与其他变量和成员基本上没有关系。
    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述注:复制构造函数,与所有构造函数享有同等权利。

    P21 07 成员对象和封闭类

    • 要点:
      1. 成员变量(形参),等价于成员变量=形参。括号()相当于赋值操作。
      2. 成员对象(形参1,形参2),等价于通过形参1和2来初始化该成员对象。具体看下面的例子。
      3. 封闭类的构造函数后跟有冒号和成员变量的参数表。
    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述注:封闭类构造和析构的调用顺序:先构造的后析构;后构造的先析构。类似栈实现。构造函数:成员对象->封闭类。析构函数:封闭类->成员对象。

    P22 08 友元(Friend)

    • 要点:
      1. 友元函数和友元类
    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

    P23 09 this指针

    • 要点:
      1. this指针可以理解为C++程序转换为C程序所用到的指针。
    • 课件
      • 如下:
        在这里插入图片描述注:C++转换成C,利用C编译器编译。因此,C++的class对应于C的结构体struct,又由于C无成员函数,故C需要定义全局函数,其全局函数的参数相比较于C++成员函数要多一个形参,即this指针,它指向C++中成员函数所作用的对象,在C中即为结构体变量。
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

    P24 10 常量对象,常量成员函数和常引用

    • 要点:
      1. const:保证其限定的成分不被修改。
      2. 常引用:对象的引用作为函数参数,不是对象,因此不会引发复制构造函数。而声明为常引用,确保形参不会修改原始值,既保证效率,又保证数据安全。
    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

    P25 01 运算符重载

    • 要点:
      1. 注意重载成普通函数和成员函数的区别。
    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

    P26 02 赋值运算符重载(浅拷贝与深拷贝)

    • 要点:
      1. 赋值=重载解决的问题:c1 = c2;等号两端类型不匹配。
      2. 运算符重载可通过重载为成员函数普通函数来实现。但赋值运算符只可重载为成员函数
    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述注:String s2 = "hello!"非赋值语句,而是初始化,它不会调用s2.operator=()成员函数,而是会调用String(char *)构造函数。
        在这里插入图片描述在这里插入图片描述在这里插入图片描述注:S1 = S2;两者指向同一块地址。S1S2消亡时,内存先后释放两次,会造成内存错误或异常终止
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述注:设计构造函数时,也要对其做与运算符重载同样的处理。

    P27 03 运算符重载为友元函数

    • 要点:
      1. 略。
    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

    P28 04 运算符重载实例:长度可变的整型数组类

    • 要点:
      1. 数组大小可变的实现方法有两种:
        • 动态申请内存:newdelete
        • 长度可变:运算符重载。
    • 课件
      • 如下:
        在这里插入图片描述
        在这里插入图片描述注:动态分配空间需要指针成员变量a2 = a;:赋值运算符重载。a2[i]:[]重载。a4(a):不能用缺省的复制构造函数,因为存在深浅拷贝的问题。
        在这里插入图片描述在这里插入图片描述注:非引用函数的返回值,不可以作为左值引用!
        在这里插入图片描述注:初始化成员列表:CArray(int s) : size(s) { ... },将size初始化为s。调用默认复制构造函数指向了同一片内存:CArray a2(a1);,会将a1的成员变量复制给a2
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述注:空间分配方案:32->64->128->...,以此类推。标准库的vector实现可变长度数组就是采用了这种方式。相比每次内存增1的方案要高效地多。

    P29 05 流插入运算符和流提取运算符的重载

    • 要点:
      1. 略。
    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

    P30 06 自增自减运算符的重载

    • 要点:
      1. 可通过全局函数成员函数来实现。
      2. 全局函数若是想访问私有成员,需要将其声明为友元
      3. 全局函数:操作数的数目等于参数个数。比成员函数多一个参数。

    • 成员函数与全局函数的区别(参考:c++:利用成员函数和全局函数实现对运算符的重载):
      1. 全局变量可以在整个程序里使用;而局部变量只可以在一个函数或一段代码中使用。
      2. 类成员函数是面向对象,全局函数是面向过程。
      3. 类成员函数 => 全局函数:增加一个参数,增加的这个参数代替this指针。
      4. 全局函数 => 类成员函数:减少一个参数,减少的这个参数由this指针隐藏。

    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述注:深浅复制是在成员变量是指针时所考虑的。
        在这里插入图片描述在这里插入图片描述

    P31 01 继承和派生

    • 要点:
      1. 略。
    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述注:PrintInfo()非重载,而是覆盖!因为重载:函数名相同,参数表不同。而覆盖是同名同参数表。
        在这里插入图片描述在这里插入图片描述

    P32 02 复合关系和继承关系

    • 要点:
      1. 类间关系包含以下三种:
        1. 没关系
        2. 继承关系:
        3. 复合关系:
    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述注:使Circle方便操作center的成员变量,最好声明为CPoint的友元函数。
        在这里插入图片描述在这里插入图片描述在这里插入图片描述注:这样的定义方式是:人中有狗,狗中有人。重复定义,CMaster体积包含1个CDog对象,而CDog体积又包含CMaster
        在这里插入图片描述注:这种定义方式,如何维护不同的狗的相同的主任的信息一致性问题。修改一个狗主人信息,需要全部修改。
        在这里插入图片描述注:复合关系的定义:类的成员对象是另一个类的固有属性或组成成分。而狗非主人的固有属性。狗没有了狗格“人格”:对狗操作,必须要对其主人进行操作,没有自由,不能独立活动。
        在这里插入图片描述注:一个类是另一个类的指针,称两个类是知道的关系。一个类的对象通过指针就能知道另一个类的对象。类似于双向树

    P33 03 基类派生类同名成员和Protected关键字

    • 要点:
      1. 基类派生类的同名成员包括:同名成员变量、同名成员函数。不推荐!
      2. 同名条件下,访问基类成员的方式:
        • 函数访问:基类::成员
        • 对象访问:对象.基类::成员
      3. 派生类不能访问基类的私有成员变量。必须声明为protected类型才行,但是也只能允许当前对象访问。
    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述
        在这里插入图片描述在这里插入图片描述在这里插入图片描述

    P34 04 派生类的构造函数

    • 要点:
    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述

    P35 05 public继承的赋值兼容规则

    • 要点:
      1.派生类构造函数前会从最顶层基类开始依次执行各个基类的构造函数。
    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

    P36 01 多态和虚函数

    • 要点:
      1. 多态:提高程序可扩充性。
      2. 虚函数可参与多态,而普通成员函数不能。
    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述
        在这里插入图片描述

    P37 02 使用多态的游戏程序实例

    • 要点:
      1. 新增怪物:使用多态可以使得代码改动和增加量最小。
      2. 新增怪物可通过基类指针指向派生类对象来实现。
      3. 顶层基类:概括了所有怪物的共同特点。
    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述注:基类指针p是一个指向派生类对象的指针,保存了派生类对象的地址。利用了public继承的赋值兼容规则3:派生类对象的地址可以赋值给基类指针

    P38 03更多多态程序实例

    • 要点:
      1. 纯虚函数:无函数体
    • 问题1:为什么构造函数和析构函数中调用虚函数,不是多态?
      理由:当一个派生类对象那个初始化时,会先执行基类对象的构造函数。在基类对象的构造函数执行期间,派生类对象它自己的那部分成员变量还未被初始化。如果在基类构造函数执行期间调用虚函数,还允许虚函数是多态的话,那么在基类的构造函数执行期间就会调用派生类的虚函数,这是由于多态,这时派生类对象它自己的成员变量还未被初始化好,此时执行派生类对象的成员函数,有可能不正确。因此,不能在基类的构造函数执行派生类的虚函数。
    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述注:pShape[i]:基类指针;PrintInfo():基类和派生类的同名虚函数。因此为多态:指向的对象为哪个派生类,就调用哪个对象的虚函数。
        在这里插入图片描述注:*S1:void类型,占用多少个字节未知,因此直接取内容会编译出错。
        在这里插入图片描述
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述注:this:基类指针;func2():虚函数。因此调用过程取决于this指针是哪种类型的对象。
        在这里插入图片描述在这里插入图片描述在这里插入图片描述

    P39 04 多态实现原理

    • 要点:
      1. 每一个含有虚函数的类(基类或继承含有虚函数的基类的派生类)都有一个虚函数表。虚函数表存放了所有虚函数的内存地址。
      2. 多态的代价:会有额外的时间和空间开销。其中,时间开销是查找虚函数表;空间开销是每个对象都多了4个字节的内存空间,存放虚函数表。
    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

    P40 虚析构函数

    • 要点:
      1. 通过基类指针删除派生类对象时(delete p),仅调用基类析构函数。导致派生类无法回收内存空间。
      2. 基类析构函数声明为virtual,使得delete p先调用派生类析构函数,再调用基类析构函数。
    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

    P41 纯虚函数和抽象类

    • 要点:
      1. 包含纯虚函数的类,称为抽象类。
      2. 抽象类的指针和引用,只能指向由抽象类派生而来的派生类的对象。
      3. 派生类实现抽象类的所有纯虚函数,才能称为非抽象类。包含一对{}也相当于实现化。
    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

    P42 文件操作

    • 要点:
      1. ifstream:input。从文件中读取数据,输入到文件流对象。
      2. ofstream:output。文件流对象输出,写入数据到文件中,
      3. fstream:既可读取数据,也能写入数据。
      4. 文件读取必须遵循以下流程:打开文件 -> 读/写文件 -> 关闭文件。
    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述
    • 示例
    std::ofstream bbox_file;
    bbox_file.open("dump/bbox_file.txt");
    if(bbox_file.is_open()){
      for(int i=0; i<(1000*364); i++)
        bbox_file << reinterpret_cast<float*>(input_cpu[0])[i] << std::endl;
    } else {
      LOG(INFO) << "Error open dump/bbox_file.txt!";
    }
    bbox_file.close();
    

    P43 函数模板

    • 要点:
      1. C++突出特性:抽象、封装、继承、多态、模板。
      2. 函数模板 => 泛型程序设计。
      3. 函数模板简单地实现 “重载”的功能。例如Swap交换intfloatdouble等。
      4. 模板 + 重载 ,需要定义多个参数类型避免二义性。
    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

    P44 类模板

    • 要点:
      1. 类模板中的函数模板的类型参数不能使用同一个。
    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

    P45 string类

    • 要点:
      1. string,模板类实现
    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

    P46 输入输出

    • 要点:
    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述注:cin >> x强制类型转换运算符的重载。虽然返回值为cin,经过fstream强制类型转换为布尔类型的值。
        在这里插入图片描述在这里插入图片描述注:peek读入但不流失,可判断输入流的数据类型。EOF = -1
        在这里插入图片描述

    P47 STL 标准模板库

    • 要点:
      1. 容器使用前,一定要了解各个容器的时间复杂度。针对具体情况,择优选取。
      2. 顺序容器:vector 动态数组(32->64->128->256);deque 双向队列(两端增删,性能佳);list 双向链表。
      3. 关联容器:排好序的,查找速度快。set:集合;multiset:允许有相同元素;map:字典(key:value);multimap:允许key相同。
      4. 容器适配器:stackqueueprority-queue:优先级队列。
      5. 反向迭代器++,会指向前一个元素,与正向不同。
      6. 双向迭代器* p返回的是引用。
    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述
        在这里插入图片描述

    P49 顺序容器vector

    • 要点:
    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

    P50 List和Deque

    • 要点:
    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

    P51 函数对象

    • 要点:
    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

    P52 set 和 multiset

    • 要点:
    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

    P53 map和multimap

    • 要点:
    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

    P54 容器适配器

    • 要点:
    • 课件
      • 如下:
        在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

    P55

    • 要点:
    • 课件
      • 如下:

    未完待续…

    展开全文
  • 基础知识重于山啊!! 数组,,对象,个个突破
  • 1.Java是跨平台的语言。 编号 选项 A T B F 2.Java不直接使用指针。 编号 选项 A T B F 3.可以使用jar来打包程序。 编号 选项 A F B T 4.add(xxxx) 可以将按钮等对象加入到...

    java程序设计mooc攻略

    单元测验互评作业考试
    week1测验2019冬期中测验
    week2测验week2互评作业2019冬期末测验
    week3测验week3互评作业
    week4测验week4互评作业
    week5测验week5互评作业
    week6测验week6互评作业
    week7测验week7互评作业
    week8测验week8互评作业
    week9测验week9互评作业
    week10测验week10互评作业
    week11测验吃不消,我自己是github上找了个项目上去

    1.Java是跨平台的语言。

    编号选项
    AT
    BF

    2.Java不直接使用指针。

    编号选项
    AT
    BF

    3.可以使用jar来打包程序。

    编号选项
    AF
    BT

    4.add(xxxx) 可以将按钮等对象加入到Frame中。

    编号选项
    AF
    BT

    5.字符串连接运算符其实是用append来实现的。

    编号选项
    AT
    BF

    6.javap –c命令可以反汇编代码。

    编号选项
    AF
    BT

    7.break及continue后面可以跟一个语句标号。

    编号选项
    AT
    BF

    8.增强的for语句可以方便地遍历数组。

    编号选项
    AF
    BT

    9.数组元素都会隐式初始化。

    编号选项
    AF
    BT

    10.如果没有定义任何构造方法,系统会自动产生一个构造方法。

    编号选项
    AT
    BF

    11.方法重载是多态(polymorphism)的一种方式。

    编号选项
    AT
    BF

    12.一个类只能有一个直接父类。

    编号选项
    AF
    BT

    13.Java中的继承是通过extends关键字来实现的。

    编号选项
    AT
    BF

    14.如果没有extends子句,则该类默认为java.lang.Object的子类。

    编号选项
    AF
    BT

    15.使用super访问父类的域和方法。

    编号选项
    AT
    BF

    16.在构造方法中,使用super()时,必须放在第一句。

    编号选项
    AF
    BT

    17.同一包中的各个类,默认情况下可互相访问。

    编号选项
    AT
    BF

    18.在定义final局部变量时,也必须且只能赋值一次。

    编号选项
    AF
    BT

    19.在接口中定义的常量具有public, static, final的属性。

    编号选项
    AF
    BT

    20.虚方法调用是由对象实例的类型来动态决定的。

    编号选项
    AF
    BT

    21.在构造方法中,如果没有this及super,则编译器自动加上super()。

    编号选项
    AF
    BT

    22.实例初始化,先于构造方法{}中的语句执行。

    编号选项
    AF
    BT

    23.内部类中访问外部类的字段可以用“外部类名.this.字段”的方式。

    编号选项
    AT
    BF

    24.Error是Throwable的子类。

    编号选项
    AT
    BF

    25.getCause()可以得到异常的内部原因。

    编号选项
    AF
    BT

    26.现在很多Java集成开发工具都提供了对JUnit的支持。

    编号选项
    AT
    BF

    27.Java的垃圾回收要由程序员自己来进行。

    编号选项
    AF
    BT

    28.类名一定要与文件同名。

    编号选项
    AT
    BF

    29.java中的enum是整数。

    编号选项
    AT
    BF

    30.虚方法调用是指编译时就决定了调用哪个类中的哪个方法。

    编号选项
    AT
    BF

    31.Java中的方法默认不是虚方法,需要用特殊的关键字才能表明是虚方法。

    编号选项
    AF
    BT

    32.abstract类必须包含abstract方法。

    编号选项
    AF
    BT

    33.如果省略访问控制符,则表示private。

    编号选项
    AT
    BF

    34.static函数中可以使用this。

    编号选项
    AF
    BT

    35.static函数可以直接使用类名来访问,不能用对象实例来访问。

    编号选项
    AF
    BT

    36.如果一个类被final所修饰,说明这个类不能被实例化。

    编号选项
    AF
    BT

    37.如果一个类被abstract所修饰,说明这个类没有构造方法。

    编号选项
    AT
    BF

    38.实例初始化,先于静态初始化执行。

    编号选项
    AF
    BT

    39.内部类中不能访问外部类的private字段及方法。

    编号选项
    AT
    BF

    40.catch多个异常时,子类异常要排在父类异常的后面。

    编号选项
    AF
    BT

    41.finally语句是指没有异常出现时要执行的语句。

    编号选项
    AT
    BF

    42.若父类中的方法声明了throws异常,则子类Override时一定也要throws异常。

    编号选项
    AF
    BT

    43.main()的写法是public void main(int argc, String[]argv)

    编号选项
    AF
    BT

    44.声明数组时可以直接指定数组的大小。

    编号选项
    AT
    BF

    45.&表示短路与运算。

    编号选项
    AF
    BT

    46.方法签名(signature)包括参数的类型及参数的名字。

    编号选项
    AT
    BF

    47.this和super是两个不同的对象。

    编号选项
    AT
    BF

    48.Java中引用类型在赋值时,复制的是对象实体。

    编号选项
    AF
    BT

    49.Java中的char是一个字节。

    编号选项
    AT
    BF

    50.Java中非零即真。

    编号选项
    AF
    BT

    @Power By Exercises-Manager

    展开全文
  • 9) A重载的运算符声明是int operator<(A &other) const,那么以下说法中正确的是: A. 小于号左侧的A对象不可以是const的 B. 小于号右侧的A对象不可以是const的 C. 这个写法是错误的,...

    1单选(1分)

    1) 关于复制构造函数,下列说法正确的是

    A. 系统不会生成缺省复制构造函数,因此必须自己实现

    B. 复制构造函数是形如X::X(X)的函数

    C.  Myclass c1, c2;  c1.n = 1;  c2 = c1;第三句将会调用复制构造函数

    D. 调用函数A Func() {   A a(4);    return a;   }时,将会调用A的复制构造函数

    正确答案:D

    2)关于虚函数,下列说法不正确的是

    • A. 不允许以虚函数作为构造函数

    • B. 没有虚函数便无法实现多态

    • C. 一般来讲,如果一个类中定义了虚函数,则不可将析构函数也定义为虚函数

    • D. 不能用抽象类定义对象

    正确答案:C

    3) 关于 this 指针,以下说法不正确的是

    • A. static成员函数内部不可以使用this指针

    • B. 在构造函数内部可以使用this指针

    • C. 在析构函数内部可以使用 this 指针

    • D. const成员函数内部不可以使用this 指针 

    正确答案:D

    4) 以下关于多态的说法那个不正确?

    • A.  在成员函数中调用虚函数,是多态

    • B.  通过“基类对象名.函数名"的方式调用虚函数,不是多态

    • C.  多态的函数调用语句中,函数一定是虚函数

    • D.  通过“基类引用名.函数名"的方式调用虚函数,是多态

    正确答案:A

    5)  map的每个元素包括KEY(first)和VALUE(second)。关于map容器,下列哪种说法错误

    • A.  map支持下标运算符

    • B.  map的不同元素可以有相同的VALUE

    • C.  map支持STL的sort算法

    • D.  map支持双向迭代器

    正确答案:C

    6)  下列说法错误的是

    • A.  可以在一个类的友元函数中使用this指针

    • B  每个类只有一个析构函数

    • C  抽象类至少包含一个纯虚函数

    • D  构造函数不可以是virtual函数

    正确答案:A

    7) 关于继承和派生的描述中,下列说法错误的是:

    • A. 派生类的成员函数中,不能访问基类的private成员

    • B. 在派生类的析构函数执行之前,会先调用基类的析构函数

    • C. 派生类对象的地址可以赋值给基类指针

    • D. 派生类可以有和基类同名同参数的成员函数`

    正确答案:B

    8) 以下哪种使用std::sort算法的方式是不合法的:

    • A. vector<int> a; …; sort(a.begin(), a.end());

    • B. bool b[99]; …; sort(b, b + 99);

    • C. string c = “2333”; …; sort(c.begin(), c.end());

    • D. list<int> d; …; sort(d.begin(), d.end());

    正确答案:D

    9) 类A重载的运算符声明是int operator<(A &other) const,那么以下说法中正确的是:

    • A. 小于号左侧的A对象不可以是const的

    • B. 小于号右侧的A对象不可以是const的

    • C. 这个写法是错误的,因为小于号的返回类型必须是bool

    • D. 使用小于号的时候,other参数处,传进来的对象实际上会被复制一次

    正确答案:B

    10) 以下STL中的函数模板哪个可以作用于set

    • A. sort

    • B. random_shuffle

    • C. find

    • D. 都不行

    正确答案:C

    001:编程填空:二进制输出

    描述

    给出一个int表示范围内的正整数x,输出其二进制表示。一共要输出31位,不足处要补0。

    #include <iostream>
    #include <string>
    using namespace std;
    string dec2bin(int x){
    }
    int main(){
    	int n;
    	cin >> n;
    	while(n--) {
    		int x;
    		cin >> x;
    		cout << dec2bin(x) << endl;
    	}
    	return 0;
    }

    输入

    第一行是整数n(n<15),表示有n个正整数要处理
    第二行是n个正整数

    输出

    对每个给出的正整数,输出其二进制表示。不足31位则用0补齐到31位

    样例输入

    3
    1 2 3

    样例输出

    0000000000000000000000000000001
    0000000000000000000000000000010
    0000000000000000000000000000011

    答案:

    #include <iostream>
    #include <string>
    using namespace std;
    string dec2bin(int x){
        string bina = "";
        while (x != 0) {
            bina += to_string(x % 2);
            x /= 2;
        }
        while (bina.length() < 31) {
            bina += to_string(0);
        }
        string b = "";
        b.resize(31);
        for (int i = 0; i <= 30; i++) {
            b[i] = bina[30 - i];
        }
        return b;
    }
    int main(){
    	int n;
    	cin >> n;
    	while(n--) {
    		int x;
    		cin >> x;
    		cout << dec2bin(x) << endl;
    	}
    	return 0;
    }

    002:编程填空:统计动物数量

    描述

    代码填空,使得程序能够自动统计当前各种动物的数量

    #include <iostream>
    using namespace std;
    void print() {
    	cout << Animal::number << " animals in the zoo, " << Dog::number << " of them are dogs, " << Cat::number << " of them are cats" << endl;
    }
    
    int main() {
    	print();
    	Dog d1, d2;
    	Cat c1;
    	print();
    	Dog* d3 = new Dog();
    	Animal* c2 = new Cat;
    	Cat* c3 = new Cat;
    	print();
    	delete c3;
    	delete c2;
    	delete d3;
    	print();
    }

    输入

    输出

    0 animals in the zoo, 0 of them are dogs, 0 of them are cats
    3 animals in the zoo, 2 of them are dogs, 1 of them are cats
    6 animals in the zoo, 3 of them are dogs, 3 of them are cats
    3 animals in the zoo, 2 of them are dogs, 1 of them are cats

    样例输入

    None

    样例输出

    0 animals in the zoo, 0 of them are dogs, 0 of them are cats
    3 animals in the zoo, 2 of them are dogs, 1 of them are cats
    6 animals in the zoo, 3 of them are dogs, 3 of them are cats
    3 animals in the zoo, 2 of them are dogs, 1 of them are cats
    

    答案:

    #include <iostream>
    using namespace std;
    class Animal {
    public:
        static int number;
        Animal() {
            number++;
        }
        Animal(Animal &a) {
            number++;
        }
        virtual ~Animal() {
            number--;
        }
    };
    class Dog :public Animal {
    public:
        static int number;
        Dog() {
            number++;
        }
        Dog(Dog &a) {
            number++;
        }
        ~Dog() {
            number--;
        }
    };
    class Cat :public Animal {
    public:
        static int number;
        Cat() {
            number++;
        }
        Cat(Cat &a) {
            number++;
        }
        ~Cat() {
            number--;
        }
    };
    int Animal::number = 0, Dog::number = 0,Cat::number=0;
    void print() {
    	cout << Animal::number << " animals in the zoo, " << Dog::number << " of them are dogs, " << Cat::number << " of them are cats" << endl;
    }
    
    int main() {
    	print();
    	Dog d1, d2;
    	Cat c1;
    	print();
    	Dog* d3 = new Dog();
    	Animal* c2 = new Cat;
    	Cat* c3 = new Cat;
    	print();
    	delete c3;
    	delete c2;
    	delete d3;
    	print();
    }

    003:编程填空:简单的计算

    描述

    补充代码,使程序按要求输出 
     

    #include <iostream>
    using namespace std;
    template <class T>
    class Add{
    public:
    };
    
    int main(){
    	double f;
    	int n;
    	while( cin >> f >> n) {
    		
    		Add<double> a1(f);
    		Add<int> a2(n);
    		double x,y;
    		int p,q;
    		cin >> x >> y >> p >> q;
    		cout << a1(x, y) << endl;
    		cout << a2(p, q) << endl;
    	}
    	return 0;
    }

    输入

    有若干组数据
    每组数据三行
    第一行是一个浮点数f和一个整数 n
    第二行是两个浮点数 x 和 y
    第三行是两个整数 p 和q

    输出

    对每组数据
    先输出 x + y - f
    再输出 p + q - n

    样例输入

    2.2 3
    1.0 2.0
    10 20
    4.5 30
    4.8 9.2
    100 200

    样例输出

    0.8
    27
    9.5
    270

    答案:

    #include <iostream>
    using namespace std;
    template <class T>
    class Add{
    public:
    float minus;
        Add(float a) :minus(a) {}
        float operator ()(T x, T y) {
            return (float)(x + y) - minus;
        }
    };
    
    int main(){
    	double f;
    	int n;
    	while( cin >> f >> n) {
    		
    		Add<double> a1(f);
    		Add<int> a2(n);
    		double x,y;
    		int p,q;
    		cin >> x >> y >> p >> q;
    		cout << a1(x, y) << endl;
    		cout << a2(p, q) << endl;
    	}
    	return 0;
    }

    004:编程填空:MyClass

    补充下列代码,使得程序的输出为:
    A:3
    A:15
    B:5
    3
    15
    5

    #include <iostream>
    using namespace std;
    class CMyClassA {
    	int val;
    public:
    	CMyClassA(int);
    	void virtual print();
    };
    CMyClassA::CMyClassA(int arg) {
    	val = arg;
    	printf("A:%d\n", val);
    }
    void CMyClassA::print() {
    	printf("%d\n", val);
    	return;
    }
    int main(int argc, char** argv) {
    	CMyClassA a(3), *ptr;
    	CMyClassB b(5);
    	ptr = &a; ptr->print();
    	a = b;
    	a.print();
    	ptr = &b; ptr->print();
    	return 0;
    }

    输入

    输出

    见样例

    样例输入

    None

    样例输出

    A:3
    A:15
    B:5
    3
    15
    5

    答案:

    #include <iostream>
    using namespace std;
    class CMyClassA {
    	int val;
    public:
    	CMyClassA(int);
    	void virtual print();
    };
    CMyClassA::CMyClassA(int arg) {
    	val = arg;
    	printf("A:%d\n", val);
    }
    void CMyClassA::print() {
    	printf("%d\n", val);
    	return;
    }
    class CMyClassB :public CMyClassA {
    public:
        int val2;
        CMyClassB(int x) :CMyClassA(3 * x), val2(x) {
            printf("B:%d\n", val2);
        }
        void print() {
            printf("%d\n", val2);
        }
    };
    int main(int argc, char** argv) {
    	CMyClassA a(3), *ptr;
    	CMyClassB b(5);
    	ptr = &a; ptr->print();
    	a = b;
    	a.print();
    	ptr = &b; ptr->print();
    	return 0;
    }

    005:编程填空:又是MyClass

    描述

    补充下列代码,使得程序能够按要求输出

    #include <iostream>
    #include <cstring> 
    #include <vector>
    #include <cstdio> 
    using namespace std;
    int  a[40];
    int main(int argc, char** argv) {
    	int t;
    	scanf("%d",&t);
    	while ( t -- ) {
    		int m;
    		scanf("%d",&m);
    		for (int i = 0;i < m; ++i) 
    			scanf("%d",a+i);
    		char s[100];
    		scanf("%s",s);
    		CMyClass<int> b(a, m);
    		CMyClass<char> c(s, strlen(s));
    		printf("%d %c\n", b[5], c[7]);
    	}
    	return 0;
    }

    输入

    第一行是整数t表示数据组数 
    每组数据有两行 
    第一行开头是整数m,然后后面是m个整数(5 < m < 30)
    第二行是一个没有空格的字符串,长度不超过50

    输出

    对每组数据 先输出m个整数中的第5个,然后输出字符串中的第7个字符。
    "第i个"中的 i 是从0开始算的。

    样例输入

    1
    6 1 3 5 5095 8 8
    helloworld

    样例输出

    8 r
    #include <iostream>
    #include <cstring> 
    #include <vector>
    #include <cstdio> 
    using namespace std;
    template<class T>
    class CMyClass {
    public:
        T *p;
        CMyClass(T*s, int wid) {
            p = new T[wid];
            for (int i = 0; i < wid; i++) {
                p[i] = *s;
                s++;
            }
        }
        T operator[](int x) {
            return *(p + x);
        }
    };
    int  a[40];
    int main(int argc, char** argv) {
    	int t;
    	scanf("%d",&t);
    	while ( t -- ) {
    		int m;
    		scanf("%d",&m);
    		for (int i = 0;i < m; ++i) 
    			scanf("%d",a+i);
    		char s[100];
    		scanf("%s",s);
    		CMyClass<int> b(a, m);
    		CMyClass<char> c(s, strlen(s));
    		printf("%d %c\n", b[5], c[7]);
    	}
    	return 0;
    }

    006:编程填空:去除重复元素排序

    描述

    程序填空,使其按要求输出

    #include <iterator>
    #include <vector>
    #include <map>
    #include <set>
    #include <queue>
    #include <algorithm>
    #include <stack>
    #include <iostream>
    #include <set>
    using namespace std;
    
    int main() {
    	int t;
    	int  a[100];
    	cin >> t;
    	while(t--) {
    		for(int i = 0;i < 12; ++i)
    			cin >> a[i];
    std::copy(b.begin(), b.end(), c);
    		cout << endl;
    
    	}
    	return 0;
    }
    #include <iterator>
    #include <vector>
    #include <map>
    #include <set>
    #include <queue>
    #include <algorithm>
    #include <stack>
    #include <iostream>
    #include <set>
    using namespace std;
    
    int main() {
    	int t;
    	int  a[100];
    	cin >> t;
    	while(t--) {
    		for(int i = 0;i < 12; ++i)
    			cin >> a[i];
            sort(a,a+12);
            vector<int> b;
            b.push_back(a[0]);
            int tmp=0;
            for(int i=1;i<12;i++){
                if(b[tmp] == a[i])
                    continue;
                else{
                    b.push_back(a[i]);
                    tmp++;
                }
            }
            ostream_iterator<int> c(cout," ");
    std::copy(b.begin(), b.end(), c);
    		cout << endl;
    
    	}
    	return 0;
    }

    007:编程填空:按要求输出

    描述

    下列程序的输出为"10 13 18 15 17 12 16 19",  请补充代码
     

    #include <iterator>
    #include <vector>
    #include <map>
    #include <set>
    #include <queue>
    #include <algorithm>
    #include <stack>
    #include <iostream>
    #include <set>
    using namespace std;
    int  a[10] = {0, 6, 7, 3, 9, 5, 8, 6, 4, 9};
    int  b[10] = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19};
    int main(int argc, char** argv) {
    for(int i=0; i<10; i++) 
    		c[a[i]] = b[i];
    	for(it=c.begin(); it!=c.end(); it++) 
    		cout<<it->second<<" ";
    	return 0;
    }

    输入

    输出

    10 13 18 15 17 12 16 19

    样例输入

    None

    样例输出

    10 13 18 15 17 12 16 19
    #include <iterator>
    #include <vector>
    #include <map>
    #include <set>
    #include <queue>
    #include <algorithm>
    #include <stack>
    #include <iostream>
    #include <set>
    using namespace std;
    int  a[10] = {0, 6, 7, 3, 9, 5, 8, 6, 4, 9};
    int  b[10] = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19};
    int main(int argc, char** argv) {
        map<int, int>c;
        for(int i=0; i<10; i++)
            c[a[i]] = b[i];
        map<int, int>::iterator it;
    for(int i=0; i<10; i++) 
    		c[a[i]] = b[i];
    	for(it=c.begin(); it!=c.end(); it++) 
    		cout<<it->second<<" ";
    	return 0;
    }

    008:编程填空:还是Fun和Do

    描述

    填写代码,使输出结果为
    A::Fun
    B::Do
    C::Fun
    C::Do
    A::Fun
    B::Do

    #include <iostream> 
    using namespace std;
    
    class A { 
    	public: 
    		virtual void Fun() { 
    			cout << "A::Fun" << endl; 
    		}; 
    		virtual void Do() { 
    			cout << "A::Do" << endl; 
    		} 
    };
    { 
    	p.Fun(); 
    	p.Do(); 
    } 
    
    void Call2(B p) {
    	p.Fun();
    	p.Do();
    }
    
    
    
    int main() { 
    	C c;
    	B b;
    	Call1(b);
    	Call1(c); 
    	Call2(c);
    	return 0;
    }

    输入

    输出

    A::Fun
    B::Do
    C::Fun
    C::Do
    A::Fun
    B::Do

    样例输入

    None

    样例输出

    A::Fun
    B::Do
    C::Fun
    C::Do
    A::Fun
    B::Do
    #include <iostream> 
    using namespace std;
    
    class A { 
    	public: 
    		virtual void Fun() { 
    			cout << "A::Fun" << endl; 
    		}; 
    		virtual void Do() { 
    			cout << "A::Do" << endl; 
    		} 
    };
    class B:public A {
    public:
        void Do() {
            cout << "B::Do" << endl;
        }
    };
    class C:public B {
    public:
        void Do() {
            cout << "C::Do" << endl;
        }
        void Fun() {
            cout << "C::Fun" << endl;
        };
    };
    void Call1(A &p)
    { 
    	p.Fun(); 
    	p.Do(); 
    } 
    
    void Call2(B p) {
    	p.Fun();
    	p.Do();
    }
    
    
    
    int main() { 
    	C c;
    	B b;
    	Call1(b);
    	Call1(c); 
    	Call2(c);
    	return 0;
    }

    009:编程填空:简单的对象

    描述

    程序填空,使得程序输出:
    2
    1
    1
    0

    #include <iostream>
    using namespace std;
    class A
    {
    	static int num;
    public:
    	A(){num+=1;}
    	void func()
    	{
    		cout<< num <<endl;
    	}
    };
    
    int A::num=1;
    
    int main()
    {
    	A a1;
    	const A a2 = a1;
    	A & a3 = a1;
    	const A & a4 = a1;
    
    	a1.func();
    	a2.func();
    	a3.func();
    	a4.func();
    
    	return 0;
    }

    输入

    输出

    2
    1
    1
    0

    样例输入

    None

    样例输出

    2
    1
    1
    0
    #include <iostream>
    using namespace std;
    class A
    {
    	static int num;
    public:
    	A(){num+=1;}
    	void func()
    	{
    		cout<< num <<endl;
    	}
        void func()const {
            num--;
            cout << num << endl;
        }
    };
    
    int A::num=1;
    
    int main()
    {
    	A a1;
    	const A a2 = a1;
    	A & a3 = a1;
    	const A & a4 = a1;
    
    	a1.func();
    	a2.func();
    	a3.func();
    	a4.func();
    
    	return 0;
    }

    010:编程填空:回调函数

    描述

    输入x1 x2 x3 x4 x5 ,输出y = x5^5 + x4^4 + x3^3 + x2^2 + x1^1 + 1的y的值

    #include <algorithm>
    #include <iostream>
    #include <stack>
    #include <queue>
    #include <vector>
    #include <cstring>
    #include <cstdlib>
    #include <string>
    #include <cmath>
    #include <map>
    #include <set>
    
    using namespace std;
    class MyFunc
    {
    };
    int main()
    {
    	int n;
    	cin >> n;
    	while(n--) {
    		vector<MyFunc> v;
    		for (int i = 0; i < 5; ++i)
    			v.push_back(MyFunc(i+1));
    		int ans = 1;
    		for (int i = 0; i < 5; ++i)
    		{
    			int m;
    			cin >> m;
    			ans += v[i](m);
    		}
    		cout << ans <<endl;
    	}
    }

    输入

    多组数据。第一行是数据组数 n
    每组数据为一行,5个整数,x1 x2 x3 x4 x5。数值不大,不必考虑溢出

    输出

    对每组数据,输出一个整数y, y = x5^5 + x4^4 + x3^3 + x2^2 + x1^1 + 1

    样例输入

    2
    2 2 2 2 2
    1 1 1 1 1

    样例输出

    63
    6
    #include <algorithm>
    #include <iostream>
    #include <stack>
    #include <queue>
    #include <vector>
    #include <cstring>
    #include <cstdlib>
    #include <string>
    #include <cmath>
    #include <map>
    #include <set>
    
    using namespace std;
    class MyFunc
    {
    public:
        int mult;
        MyFunc(int i):mult(i){}
        int operator()(int m) {
            return pow(m, mult);
        }
    };
    int main()
    {
    	int n;
    	cin >> n;
    	while(n--) {
    		vector<MyFunc> v;
    		for (int i = 0; i < 5; ++i)
    			v.push_back(MyFunc(i+1));
    		int ans = 1;
    		for (int i = 0; i < 5; ++i)
    		{
    			int m;
    			cin >> m;
    			ans += v[i](m);
    		}
    		cout << ans <<endl;
    	}
    }

    011:编程填空:前K大的偶数

    描述

    输入n个整数,输出整数数列中大小排名前k的偶数

     

    #include <algorithm>
    #include <iostream>
    #include <stack>
    #include <queue>
    #include <vector>
    #include <cstring>
    #include <cstdlib>
    #include <string>
    #include <map>
    #include <set>
    
    using namespace std;
    class MyQueue
    {
    };
    int main()
    {
    	int t;
    	cin >> t;
    	while(t--) {
    		int n, k;
    		cin >> n >> k;
    		MyQueue q(k);
    		for (int i = 0; i < n; ++i)
    			cin >> q;
    		cout<<q;
    		cout << endl;
    	}
    	return 0; 
    }

    输入

    有多组数据
    第一行是数据组数 t
    对每组数据: 
    第一行为整数n (n>=3)和k
    接下来的一行为n个整数,保证这些整数中至少有k个偶数。

    输出

    对每组数据,输出k个整数,降序排列,表示选出来的大小排名前k的偶数

    样例输入

    2
    9 4
    1 2 4 3 6 6 7 8 9
    3 2
    18 16 14

    样例输出

    8 6 6 4
    18 16
    #include <algorithm>
    #include <iostream>
    #include <stack>
    #include <queue>
    #include <vector>
    #include <cstring>
    #include <cstdlib>
    #include <string>
    #include <map>
    #include <set>
    
    using namespace std;
    class MyQueue
    {
    public:
        int k;
        multiset<int, greater<int>> que;
        MyQueue(int _k):k(_k){}
        friend istream & operator>>(istream&is, MyQueue &a) {
            int l;
            is >> l;
            if (l % 2 == 0)a.que.insert(l);
            return is;
        }
        friend ostream & operator <<(ostream&os, MyQueue &a) {
            multiset<int>::iterator p=a.que.begin();
            int count = 0;
            for (;count<=a.k-1; p++) {
                if (count)os << " ";
                os << *p ;
                count++;
            }
            return os;
        }
    };
    int main()
    {
    	int t;
    	cin >> t;
    	while(t--) {
    		int n, k;
    		cin >> n >> k;
    		MyQueue q(k);
    		for (int i = 0; i < n; ++i)
    			cin >> q;
    		cout<<q;
    		cout << endl;
    	}
    	return 0; 
    }

    012:编程填空:Printer

    描述

    完成以下程序,使得输入的整数x,以及若干正整数,将
    大于x的正整数输出;然后输入若干字符串,将字符串长度大于x的字符串输出

    #include<iostream>
    #include<algorithm>
    #include<vector>
    #include<bitset>
    
    using namespace std;
    
    
    class Printer{
    int main(){
    
    	int t;
    	cin >> t;
    	while(t--) {
    		int n,x;
    		cin>>x>>n;
    		
    		vector<int> intVec;
    		for(int i = 0;i < n; ++i) {
    			int y;
    			cin >> y;
    			intVec.push_back(y);
    		}
    		for_each(intVec.begin(), intVec.end(), Printer(x));
    		cout<<endl;
    		
    		vector<string> strVec;
    		for(int i = 0;i < n; ++i) {
    			string str;
    			cin >> str;
    			strVec.push_back(str);
    		}
    		for_each(strVec.begin(), strVec.end(), Printer(x));
    		cout<<endl;
    	}
    	return 0;
    }

    输入

    第一行是整数t,表示一共t组数据
    每组数据有三行 
    第一行是整数x和整数 n 
    第二行是n个整数 
    第三行是n个不带空格的字符串

    输出

    对每组数据
    先按原序输出第一行中大于x的正整数(数据保证会有输出) 
    再按原序输出第二行中长度大于x的字符串 (数据保证会有输出)

    样例输入

    2
    5 6
    1 3 59 30 2 40
    this is hello please me ha
    1 1
    4
    this

    样例输出

    59,30,40,
    please,
    4,
    this,
    #include<iostream>
    #include<algorithm>
    #include<vector>
    #include<bitset>
    
    using namespace std;
    
    
    class Printer{
    public:
        int x;
        Printer(int _x):x(_x){}
        void operator()(int a) {
            if (a > x)
                cout << a << ",";
        }
        void operator()(string a) {
            if (a.length() > x)
                cout << a << ",";
        }
    };
    int main(){
    
    	int t;
    	cin >> t;
    	while(t--) {
    		int n,x;
    		cin>>x>>n;
    		
    		vector<int> intVec;
    		for(int i = 0;i < n; ++i) {
    			int y;
    			cin >> y;
    			intVec.push_back(y);
    		}
    		for_each(intVec.begin(), intVec.end(), Printer(x));
    		cout<<endl;
    		
    		vector<string> strVec;
    		for(int i = 0;i < n; ++i) {
    			string str;
    			cin >> str;
    			strVec.push_back(str);
    		}
    		for_each(strVec.begin(), strVec.end(), Printer(x));
    		cout<<endl;
    	}
    	return 0;
    }

    013:编程填空:三生三世

    描述

    近年来,国内电视剧吸引了越来越多的关注;有的以当红的演员阵容而吸引观众,比如《三生三世十里桃花》(Life After Life,Blooms Over Blooms);有的以贴近时代的剧情而备受关注,比如《人民的名义》(In the Name of People);有的则以精湛的演技赢得观众的喜欢,比如《大明王朝:1566》(Ming Dynasty: 1566)。
    你的任务是根据电视剧的不同属性(演员、剧情和演技)对电视剧进行排行。

    #include<iostream>
    #include<cstring>
    #include<list>
    #include<algorithm>
    using namespace std;
    
    class TV_Drama{
    	public:
    	char name[100];
    	int actor;
    	int story;
    	int acting_skill;
    int main(){
    	list<TV_Drama> lst;
    	int n;
    	
    	cin>>n;
    	char  _name[100];
    	int _actor, _story, _acting_skill;
    	for (int i=0; i<n; i++){
            cin.ignore();
            cin.getline(_name,100);
            cin>>_actor>>_story>>_acting_skill;
    		lst.push_back(TV_Drama(_name, _actor, _story, _acting_skill));
    	}
    
    	lst.sort();
    	for_each(lst.begin(), lst.end(), Printer);	
    	cout<<endl;
    
    	lst.sort(comparator_1);
    	for_each(lst.begin(), lst.end(), Printer);	
    	cout<<endl;
    
    	lst.sort(comparator_2());
    	for_each(lst.begin(), lst.end(), Printer);	
    	cout<<endl;
    
    	return 0;
    }

    输入

    首先输入整数n,代表电视剧的个数。接下来,对于每个电视剧有两行输入:第一行一个字符串(可能含有空格,逗号,冒号等标点符号)作为电视剧的名字;第二行包括三个整数,分别为演员阵容、剧情和演技的评分。

    输出

    输出包括三行,分别为电视剧按演员阵容、剧情和演技的排行榜(评分由高到低),电视剧名字之间以分号隔开

    样例输入

    3
    In the Name of People
    98 97 99
    Life After Life, Blooms Over Blooms
    99 82 73
    Ming Dynasty: 1566
    97 100 100

    样例输出

    Life After Life, Blooms Over Blooms;In the Name of People;Ming Dynasty: 1566;
    Ming Dynasty: 1566;In the Name of People;Life After Life, Blooms Over Blooms;
    Ming Dynasty: 1566;In the Name of People;Life After Life, Blooms Over Blooms;
    #include<iostream>
    #include<cstring>
    #include<list>
    #include<algorithm>
    using namespace std;
    
    class TV_Drama{
    	public:
    	char name[100];
    	int actor;
    	int story;
    	int acting_skill;
    
    TV_Drama(char *_name, int _actor, int _story, int _ac) :actor(_actor), story(_story), acting_skill(_ac) {
            int len = 0;
            for (int i = 0; _name[i] != '\0'; i++) {
                name[i] = _name[i];
                len++;
            }
            name[len] = '\0';
        }
        bool operator<(TV_Drama&l) {
            return actor > l.actor;
        }
    };
    void Printer(TV_Drama x) {
        cout << x.name << ";";
    }
    bool comparator_1(TV_Drama &x1,TV_Drama &x2) {
        return x1.story > x2.story;
    }
    class comparator_2{
    public:
        comparator_2() {}
        bool operator() (TV_Drama &x1, TV_Drama &x2) {
            return x1.acting_skill > x2.acting_skill;
        }
    };
    int main(){
    	list<TV_Drama> lst;
    	int n;
    	
    	cin>>n;
    	char  _name[100];
    	int _actor, _story, _acting_skill;
    	for (int i=0; i<n; i++){
            cin.ignore();
            cin.getline(_name,100);
            cin>>_actor>>_story>>_acting_skill;
    		lst.push_back(TV_Drama(_name, _actor, _story, _acting_skill));
    	}
    
    	lst.sort();
    	for_each(lst.begin(), lst.end(), Printer);	
    	cout<<endl;
    
    	lst.sort(comparator_1);
    	for_each(lst.begin(), lst.end(), Printer);	
    	cout<<endl;
    
    	lst.sort(comparator_2());
    	for_each(lst.begin(), lst.end(), Printer);	
    	cout<<endl;
    
    	return 0;
    }

    014:编程填空:矩形排序

    描述

    给定一系列边长已知的矩形,输出对矩形进行两种排序的结果。

    在第一种排序中,先按矩形的面积从大到小排序;若两个矩形的面积相同,则周长大的排在前。

    在第二种排序中,先按矩形的周长从小到大排序;若两个矩形的周长相同,则面积小的排在前。

     

    <span style="color:#231f17">#include <iostream>
    #include <set>
    using namespace std;</span>
    <span style="color:#231f17">int main() {
        multiset<Rectangle> m1;
        multiset<Rectangle, Comp> m2;
        int n, a, b;
        cin >> n;
        for (int i = 0; i < n; i++) {
            cin >> a >> b;
            m1.insert(Rectangle(a, b));
            m2.insert(Rectangle(a, b));
        }
        for (multiset<Rectangle>::iterator it = m1.begin(); it != m1.end(); it++) {
            cout << *it << endl;
        }
        cout << endl;
        for (multiset<Rectangle>::iterator it = m2.begin(); it != m2.end(); it++) {
            cout << *it << endl;
        }
    	return 0;
    }</span>

    输入

    第一行是一个整数n,表示输入的矩形个数。
    接下来n行表示了n个矩形。每行有两个整数a与b,表示该矩形的长与宽。

    输出

    先用n行输出第一种排序的结果。每行两个整数,依次表示该矩形的面积与周长。
    再输出一个空行。
    最后用n行输出第二种排序的结果。每行两个整数,依次表示该矩形的面积与周长。

    样例输入

    6
    3 8
    4 6
    10 2
    6 6
    4 8
    3 6

    样例输出

    36 24
    32 24
    24 22
    24 20
    20 24
    18 18
    
    18 18
    24 20
    24 22
    20 24
    32 24
    36 24
    #include <iostream>
    #include <set>
    using namespace std;
    class Rectangle
    {
    public:
        int a,b,area,premiere;
        Rectangle(int c,int d)
        {
            a = c;
            b = d;
            area = a*b;
            premiere = (a+b)*2;
        }
        friend bool operator < (const Rectangle& a1, const Rectangle& a2)
        {
            if(a1.area>a2.area)
                return true;
            else if(a1.area == a2.area)
            {
                if(a1.premiere>a2.premiere)
                    return true;
                else
                    return false;
            }
            else
                return false;
        }
        friend class Comp;
        friend ostream & operator<<(ostream &o, const Rectangle& a1)
        {
            o << a1.area << " "<<a1.premiere;
            return o;
        }
    };
    struct Comp{
        bool operator()(const Rectangle& a1, const Rectangle& a2)
        {
            if(a1.premiere<a2.premiere)
                return true;
            else if(a1.premiere == a2.premiere)
            {
                if(a1.area < a2.area)
                    return true;
                else
                    return false;
            }
            else
                return false;
        }
    };
    int main() {
        multiset<Rectangle> m1;
        multiset<Rectangle, Comp> m2;
        int n, a, b;
        cin >> n;
        for (int i = 0; i < n; i++) {
            cin >> a >> b;
            m1.insert(Rectangle(a, b));
            m2.insert(Rectangle(a, b));
        }
        for (multiset<Rectangle>::iterator it = m1.begin(); it != m1.end(); it++) {
            cout << *it << endl;
        }
        cout << endl;
        for (multiset<Rectangle>::iterator it = m2.begin(); it != m2.end(); it++) {
            cout << *it << endl;
        }
    	return 0;
    }

     

    展开全文
  • 中国地质大学(北京)继续教育学院 2016 中国地质大学(北京)继续教育学院 2016 年03课程考试 第 第1页(共7页) 1 2 3 4 5 6 7 8 9 10 11 12 ? Windows程序设计模拟题 单项选择题 项目文件的扩展名是1 A) exe B) dsp C)...
  • OI,ACM入门学习必备,涵盖 C++基础 STL 数据结构 搜索 动态规划等
  • 以下四个题都很基础,是最近复习C++和对象的知识做的,其中第三题考查了类型转换构造函数,第四题考查的析构函数,都非常简单。 让我感到棘手的是第一题中如何读入一个带有空格的字符串,最后解决方案是发现了cin...

    以下四个题都很基础,是最近复习C++类和对象的知识做的,其中第三题考查了类型转换构造函数,第四题考查的析构函数,都非常简单。

    让我感到棘手的是第一题中如何读入一个带有空格的字符串,最后解决方案是发现了cin.getline()函数。其次是要使用一个char c来存储用于分隔的逗号。eg:输入是mao mao,18,8092,80,80,80,80 你使用cin.getline(name,20,',');cin>>age>>id;是错的,因为age和id之间有逗号,我们应该用cin>>age>>c>>id;

    第二题的难点在于理解复制构造函数的调用次数。

    001:编程填空:学生信息处理程序

    总时间限制: 

    1000ms

    内存限制: 

    1024kB

    // 在此处补充你的代码

    描述

    实现一个学生信息处理程序,计算一个学生的四年平均成绩。

    要求实现一个代表学生的类,并且类中所有成员变量都是【私有的】。

    补充下列程序中的 Student 类以实现上述功能。

    #include <iostream>
    #include <string>
    #include <cstdio>
    #include <cstring>
    #include <sstream>
    #include <cstdlib>
    using namespace std;
    
    class Student {
    };
    
    int main() {
    	Student student;        // 定义类的对象
    	student.input();        // 输入数据
    	student.calculate();    // 计算平均成绩
    	student.output();       // 输出数据
    }

    输入

    输入数据为一行,包括:
    姓名,年龄,学号,第一学年平均成绩,第二学年平均成绩,第三学年平均成绩,第四学年平均成绩。
    其中姓名为由字母和空格组成的字符串(输入保证姓名不超过20个字符,并且空格不会出现在字符串两端),年龄、学号和学年平均成绩均为非负整数。信息之间用逗号隔开。

    输出

    输出一行数据,包括:
    姓名,年龄,学号,四年平均成绩。
    信息之间用逗号隔开。

    样例输入

    Tom Hanks,18,7817,80,80,90,70

    样例输出

    Tom Hanks,18,7817,80

    提示

    必须用类实现,其中所有成员变量都是私有的。
    输出结果中,四年平均成绩不一定为整数。

    解答:

    #include <iostream>
    #include <string>
    #include <cstdio>
    #include <cstring>
    #include <sstream>
    #include <cstdlib>
    using namespace std;
    
    class Student {
        private:
            char name[20];
            int age;
            int id;
            char c;
            float first,second,third,fouth;
            float average;
        public:
            void input()
            {
                cin.getline(name,20,',');
                cin>>age>>c>>id>>c;
                cin>>first>>c>>second>>c>>third>>c>>fouth;
            }
            void calculate()
            {
                average=(first+second+third+fouth)/4;
            }
            void output()
            {
                cout<<name<<',';
                cout<<age<<','<<id<<','<<average<<endl;
            }
    };
    
    int main() {
    	Student student;        // 定义类的对象
    	student.input();        // 输入数据
    	student.calculate();    // 计算平均成绩
    	student.output();       // 输出数据
    }

    其中cin.getline此函数会一次读取多个字符(包括空白字符)。它以指定的地址为存放第一个读取的字符的位置,依次向后存放读取的字符,直到读满N-1个,或者遇到指定的结束符为止。若不指定结束符,则默认结束符为'\n'。其语法为:

    cin.getline(字符指针(char*),字符个数N(int),结束符(char));

    002:奇怪的类复制

    总时间限制: 

    1000ms

    内存限制: 

    65536kB

    // 在此处补充你的代码

    描述

    程序填空,使其输出9 22 5

    #include <iostream>
    using namespace std;
    class Sample {
    public:
    	int v;
    };
    void PrintAndDouble(Sample o)
    {
    	cout << o.v;
    	cout << endl;
    }
    int main()
    {
    	Sample a(5);
    	Sample b = a;
    	PrintAndDouble(b);
    	Sample c = 20;
    	PrintAndDouble(c);
    	Sample d;
    	d = a;
    	cout << d.v;
    	return 0;
    }

    输入

    输出

    9
    22
    5

    样例输入

    None

    样例输出

    9
    22
    5

    解答:

    #include <iostream>
    using namespace std;
    class Sample {
    public:
    	int v;
    	Sample()
    	{
    	    v = 0;
    	}
    	Sample(int x)
    	{
    	    v = x;
    	}
        Sample(const Sample& s)
        {
            v = s.v + 2;
        }
    };
    void PrintAndDouble(Sample o)
    {
    	cout << o.v;
    	cout << endl;
    }
    int main()
    {
    	Sample a(5);
    	Sample b = a;
    	PrintAndDouble(b);
    	Sample c = 20;
    	PrintAndDouble(c);
    	Sample d;
    	d = a;
    	cout << d.v;
    	return 0;
    }

    003:超简单的复数类

    总时间限制: 

    1000ms

    内存限制: 

    65536kB

    // 在此处补充你的代码

    描述

    下面程序的输出是:

    3+4i 
    5+6i

    请补足Complex类的成员函数。不能加成员变量。

    #include <iostream>
    #include <cstring>
    #include <cstdlib>
    using namespace std;
    class Complex {
    private:
        double r,i;
    public:
        void Print() {
            cout << r << "+" << i << "i" << endl;
        }
    };
    int main() {
        Complex a;
        a = "3+4i"; a.Print();
        a = "5+6i"; a.Print();
        return 0;
    }

    输入

    输出

    3+4i
    5+6i

    样例输入

    样例输出

    3+4i
    5+6i

    解答: 

    #include <iostream>
    #include <cstring>
    #include <cstdlib>
    using namespace std;
    class Complex {
    private:
        double r,i;
    public:
        void Print() {
            cout << r << "+" << i << "i" << endl;
        }
        Complex()
        {
            r = 0;
            i = 0;
        }
        Complex(char s[])
        {
            r = s[0]-'0';
            i = s[2]-'0';
        }
    };
    int main() {
        Complex a;
        a = "3+4i"; a.Print();
        a = "5+6i"; a.Print();
        return 0;
    }

    004:哪来的输出

    总时间限制: 

    1000ms

    内存限制: 

    65536kB

    // 在此处补充你的代码

    描述

    程序填空,输出指定结果 

    #include <iostream>
    using namespace std;
    class A {
    	public:
    		int i;
    		A(int x) { i = x; }
    };
    int main()
    {
    	A a(1);
    	A * pa = new A(2);
    	delete pa;
    	return 0;
    }

    输入

    输出

    2
    1

    样例输入

    样例输出

    2
    1

    解答: 

    #include <iostream>
    using namespace std;
    class A {
    	public:
    		int i;
    		A(int x) { i = x; }
    		~A()
    		{
    		    cout<<i<<endl;
    		}
    };
    int main()
    {
    	A a(1);
    	A * pa = new A(2);
    	delete pa;
    	return 0;
    }

     

    展开全文
  • 北京邮电大学软件工程研究生的课程---数据库设计开发-0-4;1.4.1 面向对象数据模型;1.4.1 面向对象数据模型;对象与标识; 层次; 层次; 继承和嵌套; 面向对象数据库;1.4.2 ORACLE对象关系库(对象关系模型;...
  • 摘要 本文通过对一个“学生选课系统”示例的简要分析与设计,说明UML图之一类图的两种作用及存在形式,以期借此澄清有些朋友可能对类图存在的误解与困惑。前言 在OOA与OOD大行其道的今天,UML在系统分析与设计中...
  • turtle.done()# 将程序运行设计为需手动退出 库引用 及 import import<库名> <库名>.<函数名>(<函数参数>) 也可以使用** from <库名>import * **,但是不推荐,当库多了的时候容易混淆且容易重名。如果...
  • 中国石油大学北京)远程教育学院 期 末 考 试 及 答案 《 Java语言程序设计 》 学习中心:_____ 姓名:______ 学号:_______   关于课程考试违规作弊的说明 1、提交文件中涉嫌抄袭内容(包括抄袭网上、...
  • 北京邮电大学计算机考研经验分享

    千次阅读 多人点赞 2020-01-10 21:12:26
    北京邮电大学计算机专业考研比较复杂,主要由于计算机的学院众多,而且北邮招生规则不同于其他学校,所以造成同学们存在很多困惑,那么我将为大家介绍下北邮计算机/网研/网安/软件学院的考研情况。同时欢迎大家...
  • 从程序中可以看出,题目已经定义了B,而main函数中还有一个D,且B指针可以接受D对象的值,所以说明D是B的派生。根据题干已知的程序和输出做比较,可以知道D也有B的构造函数,Print()和Fun()函数。...
  • 2:Big & Base 封闭问题 程序填空,输出指定结果 #include #include using namespace std; class Base { public: int k; Base(int n):k(n) { } }; class Big { public: int v; Base b; // 在...
  •  但是,删除一个派生的对象时,应该先调用派生的析构函数,然后调用基类的析构函数。  解决办法:把基类的析构函数声明为virtual  派生的析构函数可以virtual不进行声明  通过基类的指针删除派生...
  • 1. 关于Python组合数据类型,以下描述错误的是:‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪... 组合数据类型可以分为3:序列类型、集合类型和映射类型 C. 组合数据类型能够将多...
  • 1. 以下选项对文件描述错误的是: ‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬... 文件是存储在辅助存储器上的数据序列函数或是程序的集合和抽象,文件不是。 2....
  • 北京理工大学:《Python语言程序设计》____笔记整理

    千次阅读 多人点赞 2018-05-28 19:46:21
    # 这门课程是我最强烈推荐的python入门课程之一。原因有三:其一,其更加关注编程的思想,极具有启发性;其二,”小“但系统,可扩展性强;其三,有配套线上练习和测试。...第一章:程序设计基本方法 计算机与程...
  • 领域模型和设计类图的区别

    千次阅读 2017-11-19 13:58:21
     本文通过对一个“学生选课系统”示例的简要分析与设计,说明UML图之一类图的两种作用及存在形式,以期借此澄清有些朋友可能对类图存在的误解与困惑。 前言  在OOA与OOD大行其道的今天,UML在系统分析与设计中...
  • 北京化工大学保研经验分享

    千次阅读 2019-11-05 21:53:27
    写这篇博客的目的是介绍一下如何在 北京化工大学 争取到保研资格,不是怎么保研到北京化工大学.因为有好多学弟学妹问我相关的事情,恰好有时间,整理一下,希望帮助到更多的人,注意,各个高校的保研政策略有不同,...
  • 软件是通过定制进而生产制造出来的 软件是设计开发的,而不是生产制造的B.软件没有磨损老化问题。 C.软件开发的成本很高 D.软件开发和运行必须依赖计算机环境3多选(2分)下列软件属于系统软件的是(AB)A.操作系统 B....
  • 2019年中国大学生计算机设计大赛--心得总结

    万次阅读 多人点赞 2019-07-28 22:59:12
    4C2019全国总决赛的征程终于结束了,获得了全国二等奖、三等奖各一项,分别是大数据类二等奖、数媒设计类普通组三等奖。 二、回首历程 2.1吉林大学·现场赛 2.1.1作品类别(主题 海洋世界) 数媒设计类普通组 ...
  • ACM国际大学生程序设计竞赛  ACM国际大学生程序设计竞赛(英文全称:ACM International Collegiate Programming Contest(ACM-ICPC或ICPC)是由美国计算机协会(ACM)主办的,一项旨在展示大学生创新能力、团队精神...
  • 北京理工大学软件工程复试之路

    千次阅读 多人点赞 2018-03-19 20:43:56
    年的,后来才发现,上机题是计科的题,涉及文件流,树,,重载等等,管他呢,抱着学习的态度,这些东西慢慢啃啃也是不难的,上机题,先看题,后自己先做,做完了,在把网上的答案运行一下看看结果,在把网上是代码...
  • 中国十佳大学网站设计

    千次阅读 2012-03-31 12:30:42
    关于是否发表这篇文章,我内心...我不想说什么“瘸子里面挑将军”之的话,但是我们的大学网站设计,显然大部分还停留在5年前的水平。而我挑选这些“最佳”网站的标准只有两个:兼容Firefox、美观。我甚至都无视了这
  • 对一种算法设计思想的理解或探讨 对一或一个问题的探讨及算法设计与分析 对某种或某算法的优化方法的介绍 对较难练习或习题的解题报告 对某个知识点的理解或理解思路
  • 北京邮电大学_信通院_C++上机题汇总

    千次阅读 多人点赞 2020-04-10 14:12:49
    北京邮电大学信通院上机题汇总第二单元VC++实验2.1 字母大小写转换VC++实验2.2 计算圆的周长和面积VC++实验2.3 数据的逆序输出VC++实验2.4 字符串连接VC++实验2.5 IP地址格式转换第三单元VC++实验3.1 闰年VC++实验...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 38,799
精华内容 15,519
关键字:

北京设计类大学