2016/11/12反思

最新推荐文章于 2022-02-11 22:19:08 发布

Jang1996

最新推荐文章于 2022-02-11 22:19:08 发布

阅读量629

点赞数

本文链接：https://blog.csdn.net/Jang1996/article/details/53138447

版权

2016年专栏收录该内容

20 篇文章 0 订阅

订阅专栏

对于某个double变量 a，可以使用 a == 0.0 来判断其是否为零
错！
要判断一个双精度浮点数：if( abs(f) <= 1e-15 )

初始化方式 char a[14] = "Hello, world!"; 和初始化方式 char a[14]; a = "Hello, world!"; 的效果相同
错！
数组初始化两种方式：一种逐个赋值 char a[14] ={‘H’，‘e’,'l','l','o'}；另一种 char a[14] = "Hello, world!"

char a[14]; a = "Hello, world!";错误 a为数组首地址是常量不能改变

 以下代码中，A 的构造函数和析构函数分别执行了几次：
   A*pa=new A[10]; delete []pa; 
   正确答案: B 你的答案: B (正确) 
 1、1 
10、10 
1、10 
10、1 

A*pa = new A[10]; 调用new分配原始未类型化的内存，在分配的内存上运行构造函数，即运行10次构造函数，对新建的对象进行初始化构造，返回指向分配并构造好的对象的数组指针 delete []pa; 对数组中的10个对象分别运行析构函数，然后释放申请的空间

#include<stdio.h>
char *myString()
{
    char buffer[6] = {0};
    char *s = "Hello World!";
    for (int i = 0; i < sizeof(buffer) - 1; i++)
    {
        buffer[i] = *(s + i);
    }
    return buffer;
}
int main(int argc, char **argv)
{
    printf("%s\n", myString());
    return 0;
}
正确答案: D   你的答案: A

Hello
Hello World!
Well
以上全部不正确
添加笔记
已收藏
纠错
本题知识点

编程基础  字符串  C/C++
参考解析 添加解析
213

推荐
牛客-007头像牛客-007
答案：D
函数char *myString()中没有使用new或者malloc分配内存，所有buffer数组的内存区域在栈区
随着char *myString()的结束，栈区内存释放，字符数组也就不存在了，所以会产生野指针，输出结果未知

#include<iostream>
using namespace std;
class MyClass
{
public:
    MyClass(int i = 0)
    {
        cout << i;
    }
    MyClass(const MyClass &x)
    {
        cout << 2;
    }
    MyClass &operator=(const MyClass &x)
    {
        cout << 3;
        return *this;
    }
    ~MyClass()
    {
        cout << 4;
    }
};
int main()
{
    MyClass obj1(1), obj2(2);
    MyClass obj3 = obj1;
    return 0;
}
运行时的输出结果是（）
正确答案: C   你的答案: B

11214444
11314444
122444
123444
添加笔记
已收藏
纠错
本题知识点

编程基础  C/C++
参考解析 添加解析
126

推荐
八宝菊花茶头像八宝菊花茶
C D 辨析：

关键是区分 浅/深拷贝操作 和 赋值操作:
没有重载=之前：
A a ;
A b;
a = b;
这里是赋值操作。
A a;
A b = a; 
这里是浅拷贝操作。

重载 = 之后：
A a ;
A b;
a = b;
这里是深拷贝操作（当然这道题直接返回了，通常我们重载赋值运算符进行深拷贝操作）。
A a;
A b = a; 
这里还是浅拷贝操作。

所以 MyClass obj3 = obj1; 调用的是拷贝构造函数。

如果写成 MyClass obj3; obj3 = obj1; 输出的结果就是 1203444

另：深拷贝与浅拷贝区别：
1、深拷贝是指源对象与拷贝对象互相独立，其中任何一个对象的改动都不会对另一个对象造成影响
2、浅拷贝是指源对象与拷贝对象共用一份实体，仅仅是引用的变量不同（名称不同），对其中任何一个对象的改动都会影响另一个对象。

#include<stdio.h>
void main()
{
    short *p,*q;
    short arr[15]={0};
    p=q=arr;
    p++;
    printf("%d,",p-q);
    printf("%d,",(char*)p-(char*)q);
    printf("%d",sizeof(arr)/sizeof(*arr));
}
正确答案: D   你的答案: A

1,0,15
0,2,1
1,1,15
1,2,15
添加笔记
求解答(29)
已收藏
纠错
本题知识点

C/C++
共有18条讨论 添加解析
59

大菜鸟大菜狗头像大菜鸟大菜狗
D
指针自增、自减每次移动的偏移量是指针所指向对象的字节大小，所以p++与q的偏移量是2个字节。
指针相减的值是指针地址的偏移除以指针每次移位的大小；
1)p-q=1;偏移量为2个字节，每次移动2个字节，所以为1
2)(char *)p-(char *)q，指针的偏移没变，但是每次指针移位是按照（char*）类型移动，即每次移动1个字节，所以是2
3）数字每次元素2个字节，所以sizeof(arr)为30，sizeof(*arr)为2。

#include <iostream>
using namespace std;

class A {
    public:
    ~A() {
        cout << "~A()";
    }
};
class B{
    public:
    virtual ~B() {
    cout << "~B()";
}
};
class C: public A, public B {
    public:
    ~C() {
        cout << "~C()";
    }
};
int main() {
    C * c = new C;
    B * b1 = dynamic_cast<B *>(c);
    A * a2 = dynamic_cast<A *>(b1);
    delete a2;
}
则程序输出：
正确答案: D   你的答案: A

~C()~B()~A()
~C()~A()~B()
A)B)都有可能
以上都不对
添加笔记
已收藏
纠错
本题知识点

C/C++  迅雷
参考解析 添加解析
30

推荐
Aesthetic92头像Aesthetic92
答案：选D
答案解析：创建一个类对象c，然后动态类型转换，让一个B *b1指针指向c，再一次动态类型转换，让一个基类A *a2指针指向b1，当delete a2时，调用析构函数，但是基类A的析构函数不是虚函数，所以只调用A的析构函数，结果应该是：~A()

main()函数中，第一句只用了new，调用了构造函数，没用delete，不会调用析构函数，内存泄露。第二句、第三句只是定义了指向不同对象的指针，不会产生对象，所以构造函数、析构函数都没调用，最后一句delete调用析构函数，因为基类A的析构函数不是虚函数，所以只调用A的析构函数，输出：~A()，如果A的析构函数加上virtual, 输出：~C()~B()~A()，与直接delete c输出一样。 析构函数声明为虚函数，这样析构时，先调用派生类的析构函数，再调用基类的析构函数，防止内存泄露。

class A
{
    int _a;
public:
    A(int a): _a(a)
    {
    }
    friend int f1(A &);
    friend int f2(const A &);
    friend int f3(A);
    friend int f4(const A);
};
以下调用哪个是错误的：
f1(0)
f2(0)
f3(0)
f4(0)
添加笔记
邀请回答
已收藏
分享
纠错
11个回答 添加回答
30

推荐
墨儿
答案 A
解释：
非常量引用的初始值必须为左值

要理解这个先得理解左值和右值的概念
一个区分左值与右值的便捷方法是：看能不能对表达式取地址，如果能，则为左值，否则为右值。
本题举例：
执行f1(0),实参0要传成A对象，那么执行
A &a1 = 0;   //这是不行的。
执行f2(0),实参0要传成A对象，那么执行 
const A &a2 = 0;//这是可行的。


编辑于 2015-02-04 20:23:41回复(0)

请输入你的观点
回复
11

牛客666820号
选A。
 非常量引用必须是左值


左值和右值都是针对表达式而言的，左值是指表达式结束后依然存在的持久对象，右值是指表达式结束时就不再存在的临时对象。
在标准C++语言中，临时量（术语为右值，因其出现在赋值表达式的右边）可以被传给函数，但只能被接受为const &类型。

函数形式参数是临时量，是右值。所以只能被接受为const &类型 。故A错。

另：关于此题中函数参数只有类型而没有对象的问题，因为题中函数只是声明，编译器找到声明，只做类型检查。