2016/11/9 反思

如果友元函数重载一个运算符时，其参数表中没有任何参数则说明该运算符是：
正确答案: D   你的答案: A (错误)

一元运算符
二元运算符
选项A）和选项B）都可能
重载错误
添加笔记
求解答(13)
收藏
纠错
本题知识点

C/C++  迅雷
共有12条讨论 添加解析
19

若水/爆米花头像若水/爆米花
友元函数重载时,参数列表为1,说明是1元,为2说明是2元
成员函数重载时,参数列表为空,是一元,参数列表是1,为2元

#include <stdio.h>
#define SQR( X ) X * X
main( )
{
    int a=10, k=2, m=1;
    a / = SQR( k+m )/SQR( k+m );
    printf( "%d\n" ,a );
}
程序运行后的输出结果是?
正确答案: B   你的答案: A (错误)

0
1
9
10
添加笔记
收藏
纠错
本题知识点

C/C++
参考解析 添加解析
5

推荐
晴艾头像晴艾
本题考查宏定义,宏定义只是做个简单的替换,执行SQR( k+m )/SQP( k+m )=k+m*k+m/k+m*k+m=15/2, a/ = SQR( k+m )的结果为1, 选项B正确。

int f1(float);
int f2(char);
int f3(float);
int f4(float);
int (*pf)(float);
则以下不合法的是:()
正确答案: C   你的答案: D (错误)

int (*p)(float)=&f1;
pf=&f4;
pf=&f2;
pf=f3;


C
知识点：
函数指针变量：
函数指针变量的声明方法为：
返回值类型 ( * 指针变量名) ([形参列表]);
根据定义，
int(*pf)(float);
int (*p)(float)=&f1;
pf,p都是函数指针变量。
函数地址
C在编译时，每一个函数都有一个入口地址，该入口地址就是函数指针所指向的地址。
函数地址的获取，可以是函数名，也可以在函数名前加取地址符&

C错误是因为函数行参类型不匹配。





发表于 2015-09-28 10:54:07 回复(2)
3

媛媛不贪睡头像媛媛不贪睡
函数名等价于函数名取地址C

以下哪些对象可用于Windows进程间通信？
正确答案: D   你的答案: C (错误)

事件
临界区
互斥量
共享内存
添加笔记
收藏
纠错
本题知识点

Windows  C/C++  完美世界
参考解析 添加解析
17

推荐
魅之影_正头像魅之影_正
正确答案：D
进程间通信方法有：文件映射、共享内存、匿名管道、命名管道、邮件槽、剪切板、动态数据交换、对象连接与嵌入、动态连接库、远程过程调用等
没有A、B、C选项

下面程序段包含4个函数,其中具有隐含this指针的是()
1
2
3
4
5
6
7
int f1();
class T
{
    public:static int f2();
    private:friend int f3();
    protect:int f4();
};
正确答案: D   你的答案: C (错误)

f1
f2
f3
f4
添加笔记
求解答(6)
收藏
纠错
本题知识点

C/C++
共有5条讨论 添加解析
15

zt_xcyk头像zt_xcyk
D
静态成员函数属于整个类所拥有，没有this指针
友员函数不是这个类的成员，没有
类的非静态成员函数  有

#include < stdio,h>
main()
{
    int a =3;
    a + =a - =a *a;
    printf("%d\n ,a);
}
程序的输出结果是？
等号"="运算符是从右到左,且与"+、-、*"运算符比,优先级较低。首先计算a *a 结果为9,执行a=a-9,a的值为-6,然后执行a +=a,即a=a +a=-6+(-6),所以值为-12。

dynamic_cast : 
继承体系安全向下转型或跨系转型；找出某对象占用内存的起始点
static_cast:
同旧式C转型，如int 到double
const_cast:
常用于去除某个对象的常量性
reinterpret_cast
不具备移植性，常见用途是转化函数指针类型

假定指针变量p定义为“int *p=new int(100);”，要释放p所指向的动态内存，应使用语句（ ）
正确答案: A   你的答案: D (错误)

delete p;
delete *p;
delete &p;
delete []p;
添加笔记
求解答(1)
收藏
纠错
本题知识点

C/C++  奇虎
共有8条讨论 添加解析
12

骑着炮弹进城头像骑着炮弹进城
答案：A
int* p = new int (100) 是创建一个int型的内存，并赋值为100; 
int *p = new int[100] 是创建100个int型的内存;
一般用法是new一个数组的话一般是delete [] 其他的直接delete即可。
但是其实对于内置数据类型，其实是delete[] 和delete都可以的。

#include<stdio. h>
int fun(char *s)
{ 
    char *p=s;
    while(*p !='\0') p++;
    return(p-s);
}
main()
{ 
    printf("%d\n",fun("goodbye!"));
}
程序的输出结果是?
正确答案: D   你的答案: 空 (错误)

0
6
7
8
添加笔记
收藏
纠错
本题知识点

C/C++
参考解析 添加解析
1

推荐
Mt头像Mt
本题主要考查了函数定义及调用,以及while循环语句,执行fun函数后,首先是找到最后一个字符的地址,然后减去第一个地址得到的就是这个字符串的长度,所以本题答案为8。

面向对象的五个原则
五个基本原则： 
单一职责原则（Single-Resposibility Principle）：一个类，最好只做一件事，只有一个引起它的变化。单一职责原则可以看做是低耦合、高内聚在面向对象原则上的引申，将职责定义为引起变化的原因，以提高内聚性来减少引起变化的原因。 
开放封闭原则（Open-Closed principle）：软件实体应该是可扩展的，而不可修改的。也就是，对扩展开放，对修改封闭的。 
Liskov替换原则（Liskov-Substituion Principle）：子类必须能够替换其基类。这一思想体现为对继承机制的约束规范，只有子类能够替换基类时，才能保证系统在运行期内识别子类，这是保证继承复用的基础。 
依赖倒置原则（Dependecy-Inversion Principle）：依赖于抽象。具体而言就是高层模块不依赖于底层模块，二者都同依赖于抽象；抽象不依赖于具体，具体依赖于抽象。 
接口隔离原则（Interface-Segregation Principle）：使用多个小的专门的接口，而不要使用一个大的总接口

下面关于typedef char *String_t; 和#define String_d char * 这两句在使用上的区别描述错误的是？
正确答案: C   你的答案: C (正确)

typedef char *String_t 定义了一个新的类型别名，有类型检查
#define String_d char * 只是做了个简单的替换，无类型检查
前者在预编译的时候处理，后者在编译的时候处理
同时定义多个变量的时候有区别，主要区别在于这种使用方式String_t a,b; String_d c,d; a,b ,c 都是char*类型，而d 为char 类型

为了建立如图所示的存储结构(即每个结点含两个域,data是数据域,next是指向结点的指针域),则在[] 处应填入选项是
struct link 
{ 
    char data;
    []; 
} node;

正确答案: B   你的答案: C (错误)

link next;
struct link * next;
link * next;
struct link next;
添加笔记
收藏
纠错
本题知识点

C/C++
参考解析 添加解析
0

推荐
thejojo头像thejojo
本题主要考查链表中结点的概念,属于基础知识,其中指针域应该是指向下个结点,所以答案为B。
编辑于 2015-02-03 17:20:21 回复(1)
更多回答(5条)
22

之行头像之行
在C++中B、C都行，但在C中只有B行。因为在C++中可以有不完全的类类型，就是在类中可以声明类自身的指针和引用。
发表于 2015-07-14 21:32:13

const char str1[]=”abc”;
const char str2[]=”abc”;
const char *p1 = “abc”;
const char *p2 = “abc”;
判断下列说法哪个是正确的(注意是地址)：______。
正确答案: C   你的答案: A (错误)

str1和str2地址不同，P1和P2地址相同。
str1和str2地址相同，P1和P2地址相同。
str1和str2地址不同，P1和P2地址不同。
str1和str2地址相同，P1和P2地址不同。
4个地址都相同
添加笔记
求解答(3)
收藏
纠错
本题知识点

C/C++  阿里巴巴
共有16条讨论 添加解析
10

小小吴头像小小吴
F
str1和str2毫无干系，他们都是字符常量数组，恰巧存储的值相同而已。"abc"和str1 str2都存储在常量区。str1 str2的地址就是str1[0] str2[0]的地址，即数组首元素所在的地址。
后面的两个“abc”存储在常量区，因为他们是字面值（常量），但是p1 p2存储在栈中。其中p1和p2的值不同，但是他们指向同一块静态存储区域。也就是"abc"的地址。

这个可以从@Sinmaxwell 的回答中直观的感受到。
发表于 2015-01-12 21:37:07 回复(1)
17

＆Builder头像＆Builder
1
2
3
4
5
6
7
8
9
这个问题这么纠结，还是我们没看清题目。问题中问的是四个指针的地址。当运行
cout << &str1 << endl << &str2 << endl << &p1 << endl <<& p2 << endl;
时，四个地址的结果为
0xbfdb9a7c
0xbfdb9a78
0xbfdb9a74
0xbfdb9a70
四个都是不一样的。
但是要是说指针的值的话，那么str1与str2是不同的，p1,p2是相同的。

int* pint = 0; 
pint += 6; 
cout << pint << endl;
以上程序的运行结果是：
正确答案: C   你的答案: F (错误)

12
72
24
0
6
任意数
添加笔记
求解答(15)
收藏
纠错
本题知识点

C/C++
共有12条讨论 添加解析
41

keviv_li头像keviv_li
第一句的意思是将pint指针指向0地址处，由于指针类型是int，每次加1相当于移动四个字节，（在int为四个字节的机器上）；加上6，地址为0x18

int* pint = 0; 
pint += 6; 
cout << pint << endl;
以上程序的运行结果是：
正确答案: C   你的答案: F (错误)

12
72
24
0
6
任意数
添加笔记
求解答(15)
收藏
纠错
本题知识点

C/C++
共有12条讨论 添加解析
41

keviv_li头像keviv_li
第一句的意思是将pint指针指向0地址处，由于指针类型是int，每次加1相当于移动四个字节，（在int为四个字节的机器上）；加上6，地址为0x18

#define INT_PTR int*
typedef int* int_ptr;
INT_PTR a,b;
int_ptr c,d;
文件中定义的四个变量中，哪个变量类型不是指针类型？
正确答案: B   你的答案: A B (错误)

a
b
c
d
都是指针
都不是指针

答案：B
#define INT_PTR int* 这是宏定义，编译预处理阶段要进行宏替换，INT_PTR a,b会变成 int* a,b 所以b不是指针类型
typedef int* int_ptr; 这是自定义类型，也就是把int_ptr定义为 int型指针，编译阶段会把c,d都识别为指针

class Test
{
    public:
        ____ int a;
        ____ int b;
    public:
        Test::Test(int _a , int _b) : a( _a )
        {
             b = _b;
        }
};
int Test::b;
int main(void)
{
    Test t1(0 , 0) , t2(1 , 1);
    t1.b = 10;
    t2.b = 20;
    printf("%u %u %u %u",t1.a , t1.b , t2.a , t2.b);
    return 0;
}
Running result : 0 20 1 20
正确答案: B C   你的答案: C (错误)

static/const
const/static
--/static
conststatic/static
None of above
添加笔记
求解答(7)
收藏
纠错
本题知识点

C/C++  微软
共有9条讨论 添加解析
15

木子鑫影头像木子鑫影
对于成员变量a，若它为const类型，那么必须要使用Test::Test(int _a , int _b) : a( _a )这种初始化形式，若它为普通成员变量，也可以采取Test::Test(int _a , int _b) : a( _a )这种形式，所以a可以为const或者普通类型，由于b没有采取Test::Test(int _a , int _b) : b( _b )这种形式，所以b一定不是const类型，有main()中的t1.b和t2.b的输出都是20可以知道，b是静态变量。

class CBuffer
{
    char * m_pBuffer;
    int m_size;
    public:
        CBuffer()
        {
            m_pBuffer=NULL;
        }
        ~CBuffer()
        {
            Free();
        }
        void Allocte(int size) （1） {
            m_size=size;
            m_pBuffer= new char[size];
    }
    private:
        void Free()
        {
            if(m_pBuffer!=NULL) (2)
            {
                delete[] m_pBuffer;
                m_pBuffer=NULL;
            }
        }
    public:
        void SaveString(const char* pText) const (3)
        {
            strcpy(m_pBuffer, pText); (4)
        }
        char* GetBuffer() const
        {
            return m_pBuffer;

    }

    };

void main (int argc, char* argv[])
{
    CBuffer buffer1;
    buffer1.SaveString("Microsoft");
    printf(buffer1.GetBuffer());
}

1
2
3
4
查看正确选项
添加笔记
求解答(5)
邀请回答
收藏
分享
纠错
11个回答 添加回答
16

For-Happy
正确答案应该为: A C D
理由: (1) 分配内存时, 未检测m_pBuffer是否为空, 容易造成内存泄露;
         (3) 常成员函数不应该对数据成员做出修改, 虽然可以修改指针数据成员指向的数据, 但原则上不应该这么做;
         (4) 字符串拷贝时, 未检测是否有足够空间, 可能造成程序崩溃。
关于const函数的一些内容：
    c++的const函数特点：
1. 不能在const函数中修改所在类的对象的数据，因为const函数中的*this是常量，同样只能访问const函数；
2. const函数中只能调用其他的const函数，不能调用非const函数，因为对象调用函数是需要传递对象自己，const函数中的*this是常量，非const函数中的*this是变量，因此不可以调用(除非去除*this的const属性)；
Note:使用const_cast后，可以在const函数中调用非const函数的
3. const函数与同名的非const函数是重载函数；
4. const对象只能调用const函数 ，但是非const对象可以调用const函数。

32位机上根据下面的代码，问哪些说法是正确的？
signed char a = 0xe0;
unsigned int b = a;
unsigned char c = a;
a>0 && c>0 为真
a == c 为真
b 的十六进制表示是：0xffffffe0
上面都不对
添加笔记
邀请回答
收藏
分享
纠错
12个回答 添加回答
47

推荐
burningsky250
同等位数的类型之间的赋值表达式不会改变其在内存之中的表现形式，因此通过 unsigned char c = a;语句，c的位存储形式还是0xe0

对于B选项，编译器首先检查关系表达式"==" 左右两边a ,c的类型，如果某个类型是比int的位宽小的类型，就会先进行Integer Promotion，将其提升为int类型，至于提升的方法，是先根据原始类型进行位扩展（如果原始类型为unsigned ,进行零扩展，如果原始类型为signed,进行符号位扩展）至32位，再根据需要进行unsigned to int 形式的转换。
因此：
a 为signed char    型，位宽比int小，执行符号位扩展，被提升为 0xffffffe0;
c 为unsigned char型，位宽比int小，执行零扩展，被提升为 0x000000e0;

经过以上步骤，再对两边进行比较，显然发现左右是不同的，因此==表达式值为false。

再举一个例子：
-------------------------------------
1
2
3
signed int a = 0xe0000000
unsigned int b = a;
cout<< (b == a) <<endl;
-------------------------------------
结果为 1, 因为a、b位宽已经达到了int的位宽，均不需要Integer Promotion,只需要对a执行从unsigned to signed的转换，然而这并不影响其在内存中的表现形式，因此和b比较起来结果为真。

参考：https://www.securecoding.cert.org/confluence/display/cplusplus/INT02-CPP.+Understand+integer+conversion+rules
牛客原题：
http://www.nowcoder.com/questionTerminal/0e4febc6e67945219e2b0dec9ba7fef3