节必知必会——问题集锦

Posted itzyjr

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了节必知必会——问题集锦相关的知识,希望对你有一定的参考价值。

必知必会问题集锦

第2章:开始学习C++

1.源代码生成可执行代码的过程?
2.编译指令usingusing namepace有何区别?
3.coutcin对应于C中的什么函数,要包含哪个头文件?
4.endl\\n有何区别?
5.main()函数返回的值是什么含义?是返回给程序其他部分还是操作系统?

第3章:处理数据

1.通过cout输出十进制、十六进制和八进制,分别用什么控制符
2.程序将把1492存储为intlong还是其他整型呢?
3.有原型:ostream& cout.put(char c);那么cout.put('$');cout << '$';有区别吗?
4.什么是通用字符名?它的用法类似于?通用字符名的表示有哪两种前缀,含义有何不同?后缀表示的那些位是字符的哪个国际标准的码点?例如:ö的国际标准码点为00F6,â的码点为00E2。请➀定义一个变量名为körper的整型变量;➁直接输出字符串:gâteau。
5.ASCIIUnicodeISO 10646之间的关系?通用字符集(Universal Character Set, UCS)是由ISO制定的哪个标准所定义的标准字符集?
6.扩展字符集用哪个类型来表示?它具体是一个什么类型?8位char不够用所以用扩展字符集吗?它在系统底层表示是unsigned short还是int或者是其他类型呢?cincout能直接用在这种宽字符类型吗?宽字符常量和宽字符串,怎么表示?在支持两字节wchar_t的系统中,将会把每个字符存储在一个几字节的内存单元中?
7.char16_tchar32_t表示的是意思分别是?它们分别使用什么前缀去表示字符常量和字符串?与wchar_t一样,它们也都有什么底层类型?
8.bool类型的字面量truefalse都可以通过提升转换为int类型吗?可以int ans = true;这样吗?ans等于什么?同样,可以bool start = -100;这样吗?start等于什么?
9.为什么C++提倡使用const代替#define
10.整型常量和浮点常量的默认类型分别是?
11.static_cast<type>(value)是什么作用?相比C的强转,它有何优点?
12.auto关键字的作用是什么?如下代码中n、x、y分别是什么类型?

auto n = 100;
auto x = 1.5;
auto y = 1.3e12L;

第4章:复合类型

1.如下代码打印出什么?为什么?

int i = 3;
int* p = &i;
char dog[8] = 'b', 'e', 'a', 'u', 'x', ' ', 'I', 'I';
char cat[8] = 'f', 'a', 't', 'e', 's', 's', 'a', '\\0';
cout << p;
cout << dog;
cout << cat;

2.如下代码运行,对应的输入,最终打印的结果有什么问题吗?为什么?
代码中cin读取单词后将字符串放到数组中,会自动在结尾添加空字符吗?

int main() 
	char name[20];
    char dessert[20];
	cout << "Enter your name:\\n";
	cin >> name;
    cout << "Enter your favorite dessert:\\n";
    cin >> dessert;
    cout << "I have some delicious " << dessert << " for you, " << name << ".\\n";
   	return 0;

Enter your name:
|Alistair Dreeb<Enter>
Enter your favorite dessert:
I have some delicious Dreeb for you, Alistair.

3.以上代码的问题,如何用其他函数来解决?
4.原始(raw)字符串,含义是?格式上来说,前缀是?定界符是?如果字符串中包含定界符,那又该用什么格式呢?如果字符串是wchar_t等类型又该是什么格式呢?
5.什么叫静态联编(static binding)?什么叫动态联编(dynamic binding)
6.使用数组名或指针时,C++都将执行下面的转换,为什么?arr[-2]代表什么意思?

arrayname[i] => *(arrayname + i)
pointername[i] => *(pointername + i)

7.自动存储、静态存储和动态存储的含义与区别?栈、堆的含义与区别?
8.使变量成为静态有哪两种方式?
9.指针数组是什么意思?声明一个指向指针数组的变量,应该是一个指针的指针吗?指针与指针的指针有何关键区别?
10.模板类vectorarray,从功能、底层机制、特点、安全和效率这几个方面对比一下?

第5章:循环和关系表达式

1.下面代码输出什么?为什么?如果要像预想的那样工作,该怎么做?

char word[] = "mate";
bool b = word == "mate";
cout << b;

2.获取时间用哪个函数?要包含哪个头文件?如何得到系统时间的秒数?
3.我们知道cin和scanf一样使用空白(空格、制表符和换行符)来确定字符串的结束位置,如果要读取单个空白符,应该用哪个函数呢?
4.EOF是什么含义?它在源代码中是被怎么定义的?在一个循环读取字符的代码中,如何模拟EOF?此时while循环的条件应该是什么?
5.while(cin)while(cin.good())while(!cin.fail())while(!cin.eof())while(!cin.bad()),它们有何异同?哪个更通用?

第6章:分支语句和逻辑运算符

1.要判断一个字符是否是字母、空格、数字、标点符号、大小写、控制符…,用哪个函数库?
2.cin.clear()函数的作用机制是什么?如何用它帮助完成输入类型不匹配时给出提示(输入只能是数字而不能是其他字符)?
3.去除输入缓存一般用哪句while循环?
4.C++为标准输入和输出定义了一些格式标志,可通过哪三个函数来控制?
5.写入到文本文件中,一般有哪四个步骤?
6.检测IO错误时,good()fail()eof()bad()它们各有何特点?

第7章:函数——C++的编程模块

1.为何编译器需要函数原型?
2.下图说明了传参的什么特点?
​​
3.对于形参func(int arr[])这里arr实际是:数组or指针?如果将形参改为int* arr可以吗?
4.在形参有何特点时,会用const修饰?目的是?
5.对于一个二维数组arr[r][c],总有恒等式arr==&arr[0]吗?怎么用指针表示法来表示这个二维数组?
6.函数也有指针,那么函数的地址是在哪呢?
7.首先着重理解typedef的妙用,问:下面代码的最后一行代码中的pd代表的意思是?

typedef const double* (*p_fun)(const double*, int);
p_fun pa[3] =  f1,f2,f3 ;// f1,f2,f3是函数名
p_fun (*pd)[3] = &pa;
const double* (*(*pd)[3])(const double *, int) = &pa;

第8章:函数探幽

1.简单描述下函数的调用过程?为什么需要内联函数?为什么提倡用内联函数替换宏定义?
2.为什么说引用看上去很像伪装表示的指针?
3.怎么理解如下代码?引用有什么特点?

int & rodents = rats;
实际上是下述代码的伪装表示:
int * const pr = &rats;// 指针常量

4.下图说明了什么?

5.下面代码打印输出什么?

#include <iostream>
using namespace std;
int main() 
	int x = 6;
	int& y = x;
	int& z = y;
	y = 9;
	cout << x << "," << y << "," << z << endl;
	z = 10;
	cout << x << "," << y << "," << z << endl;
	return 0;

6.为什么有时函数要返回引用?返回引用实际上返回的是什么?返回引用一定要注意什么?
7.什么情况下最好将返回类型声明为const引用?
8.如下代码是什么作用?要包含哪个头文件?

cout << numeric_limits<string::size_type>::max() << endl;

9.何时使用引用参数、何时使用指针参数、何时使用按值传递?
10.要设置函数默认值,是要在函数体对应的形参上标明吗?还是说必须得怎样?
11.要为某个参数设置默认值,则必须为它右边的所有参数都提供默认值吗?为什么?
12.使用默认参数,可以减少哪三方面函数的数量?
13.函数模板即是使用泛型来定义函数,那么定义一个函数模板需要在函数体顶部怎么声明?用到哪些关键字?
14.如果函数模板中的类型是个结构体,现要交换结构体的成员,用普通模板函数可以完成吗?如果不能那应该用哪种格式/类型的模板?
15.显式具体化的原型和定义应以什么打头、并通过名称来指出类型?
16.看下面代码,代码中变量xpy是什么类型?怎么解决这种情况?

template<class T1, class T2>
void ft(T1 x, T2 y) 
    ?type? xpy = x + y;

17.下面代码的返回类型怎么解决(注意要用到两个关键字,同时用到后置返回类型)?

template<class T1, class T2>
?type? gt(T1 x, T2 y) 

    return x + y;

第9章:内存模型和名称空间

1.为什么要在头文件里面定义#ifndef XXX_H #define XXX_H ..... #endif
2.cin可以连续获取值吗?比如cin >> screen.x >> screen.y,为什么?
3.下图表达出什么思想(理解图左侧栏1、2、3、4步骤)?

4.“静态”这个词只是说明具有外部链接性。C++为静态存储持续性变量提供了3种链接性,是哪3种?各有什么特点?
5.所有的静态持续变量都有的初始化特征是:未被初始化的静态变量的所有位都被设置为什么值?
6.有4种变量的存储方式,下图很好的总结了,能用自己的话简短再描述一下这4种存储方式吗?

7.C++有“单定义规则”,即变量只能有一次定义,为此,有两种变量声明,一种是定义声明,另一种是引用声明。
那么,引用声明要用哪个关键字,怎么使用?关键字用在哪个文件里?请结合下面代码示例,“在引用变量的同时对它进行赋值会破解引用而成为了定义变量”,这话怎么讲?可以在引用之后再更改引用变量的值吗?

// file1.cpp
int cats = 10;
// main.cpp
#include<iostream>
extern int cats = 20;// Error!去掉赋值“=20”一切OK! 
/* 注:赋值后就会为变量分配空间,这就成为了变量定义,就不属于单纯的引用了!*/
int main() 
	cats = 30;
	std::cout << cats;// 解决掉Error后,就能正常输出:30

运行报错:(Error message:“already defined”直观地表明“main.cpp”中引用的变量cats被赋值后就成为变量的定义了)

8.如果一个文件中有全局变量,在一个函数体里也有局部的同名变量,该如何在函数体里访问全局的同名变量呢?
9.下面代码运行会报错吗?它违反了什么规则?

// file1
int errors = 20;
----------------------------
// file2
int errors = 5;
void froobish() 
    cout << errors;

10.在.cpp文件中全局声明一个const修饰的变量,是“静态,外部链接性”吗?
11.下面代码的上半部分说明了什么问题?是什么原因导致的?代码的下半部分没任何问题,说明了#include的什么本质?

// file1.cpp
const int x = 10;// 放在.cpp文件。链接性:静态,内部
-----------------
// file2.cpp
extern const int x;// 运行后此行报错:unresolved external symbol "int const x"
/* 去掉file1.cpp与file2.cpp中的const,就正常了 */
int main() 
    cout << x;

############## 上半部分↑↑,下半部分↓↓ ##############
// dolly.h
static int x = 10;// 放在头文件,静态内部链接
const int y = 20; // 放在头文件,静态内部链接
// filey.cpp
#include "dolly.h"// 包含头文件
int main() 
	/* 直接【拥有】了头文件的内容,使成为本文件的作用域了!
	   如果要多此一举,去引用头文件的变量,也是没问题的。*/
    cout << x << "," << y; // 正常输出:10,20

12.默认函数是什么链接性?加上static关键字后呢?
13.如果要[ 在C++程序中使用C库中预编译的函数 ],将出现什么问题呢?
对于下面第一行代码,假设函数名在C翻译为_spiff,而在C++翻译为_spiff_i,extern "C/C++"必须放置在函数原型吗?它是怎么解决了问题的?

extern "C" void spiff(int);
extern "C++" void spaff(int);// 可缺省前缀,因是C++默认行为

14.如果new找不到请求的内存量,会发生什么?
15.如果想把一个数组或结构放到一个已分配内存的区域,可以用哪种方法?需要包含哪个头文件?
16.使用定位new运算符后,如下面的代码,返回的指针p2、p4该怎么使用?需要配套使用delete吗?为什么?

#include <new>
struct chaff  char dross[20]; int slag; ;
char buffer1[50];
char buffer2[500];
int main() 
    chaff *p1, *p2;
    int *p3, *p4;
    p1 = new chaff; // 把结构放进堆中
    p3 = new int[20]; // 把int数组放进堆中
    // 两种形式的new替换
    p2 = new (buffer1) chaff; // 把结构放进buffer1
    p4 = new (buffer2) int[20]; // 把int数组放进buffer2

17.书上讲到:“在默认情况下,在名称空间中声明的名称的链接性为外部(除非它引用了const常量)。”,怎么理解这句话?下面的示例揭示出的事实怎么与书上讲的是矛盾的呢?结合下面示例,最终能得出什么其他的结论呢?

// my.h
#pragma once
namespace myspace 
	int age;

// file.cpp
namespace myspaceT 
	int ageT;

// main.cpp
#include<iostream>
#include "my.h"
int main() 
	std::cout << myspace::age;// OK
	auto a = myspaceT;// undefined!
	auto b = ageT;// undefined!
	auto c = myspaceT::ageT;// no class!no namespace!
	/* 如果file.cpp中自定义的名称空间默认链接性是“外部”,
	 * 那main.cpp怎么不能直接访问到呢?根本识别不到那个名称空间的一切。
	 */


18.using声明和using编译指令有何区别?它们存在的作用是什么?
19.下面代码输出什么?

#include<iostream>
namespace Jill 
	double fetch;

double fetch;
int main() 
	std::cout << &fetch << std::endl;
	using Jill::fetch;// using声明!将fetch放入【局部名称空间】main()块作用域
	std::cin >> fetch;// 读取一个值到Jill::fetch
	std::cin >> ::fetch;// 读取一个值到全局fetch
	std::cout << fetch << "|" << ::fetch << std::endl;
	std::cout << &fetch << "|" << &(::fetch);

20.下面代码,第一行是什么?直观意思是?第二行是什么?直观意思又是什么?

using std::cout;
using namespace std;

21.为什么不提倡不分青红皂白地使用using编译指令?举例子说明。
22.未命名名称空间的链接性为?有什么特别的作用?
23.说说名称空间对编程设计蓝图带来的作用?

第10章:对象和类

1.下面代码,直接在类声明外定义私有成员函数,可行吗?为什么?
默认在类中直接给出定义的函数都是什么函数?

// stock.h
class Stock 
	private:
		long shares;
		double share_val;
		double total_val;
		void set_tot();
	public:
		......
;
inline void Stock::set_tot() 
    total_val = shares * share_val;

2.在什么情况下,编译器才会提供默认构造函数?在什么情况下你必须为类提供默认构造函数?
3.有哪两种方式定义默认构造函数?在默认构造函数里通常应该做什么操作?
4.析构函数在什么时候会被程序自动调用?
5.创建的是静态存储类对象、自动存储类对象、通过new创建的对象,这三种情况下,析构函数在何时被自动调用?
6.默认情况下,与给结构赋值一样,在给类对象赋值时(一个对象赋值给另一个对象),会执行什么操作?
7.如下代码,可能会产生临时对象吗?为什么?这时会自动调用谁的析构函数?具体是在什么时候被调用的?

int main() 
	Stock stock1("NanoSmart", 12, 20.0);// 直接创建对象
	stock1 = Stock("Nifty Foods", 10, 50.0);// 对象赋值(一个匿名对象赋值给一个对象)
	...
	return 0;

8.参考下面代码,问:对象初始化与对象赋值,有什么区别?

Stock stock1("NanoSmart", 12, 20.0);// 对象初始化(语法一)
Stock stock2 = Stock("Boffo Objects", 2, 2.0);// 对象初始化(语法二)
stock2 = stock1;// 对象赋值

9.在上面代码中,stock1与stock2都是自动变量,它们被放入哪块内存?析构的顺序是按什么规则?
10.参考如下代码,可以将列表初始化语法用于类吗?如果可以,初始化的成员要与构造函数的什么匹配?

Stock::Stock(const std::string& cmp, long n = 0, double pr = 0.0);
------------------------------------------------------------------
Stock hot_tip = "Derivatives Plus Plus", 100, 45.0;
Stock jock "Sport Age Storage, Inc";

11.看下面代码,编译器拒绝第2行代码,为什么?怎么解决(如何让成员函数不允许修改[调用对象])?

const Stock land = Stock("Kludgehorn Properties");
land.show();←编译器拒绝

12.应遵守一规则:“只要类方法不修改调用对象,就应该将其他声明为const成员函数”,对吗?
13.每个类都只能有一个析构函数吗?如果构造函数使用了new,则必须提供使用delete的析构函数吗?
14.要比较两个对象的成员,提供一个比较成员函数,如下代码和图,能悟出什么知识点(隐式访问&显示访问)?

const Stock& topval(const Stock& s) const;// 函数原型

假设要对Stock对象stock1和stock2进行比较,并将其中股价总值较高的那一个赋给top对象,则可以使用下面两条语句之一:

top = stock1.topval(stock2);
top = stock2.topval(stock1);


15.看下面代码,引发一个小问题,如何解决?

const Stock& Stock::topval(const Stock& s) const 
    if (s.total_val > total_val)// 问:这个大于号后的total_val确定是调用的对象的吗?
        return s; // 参数对象
    else
        return ?????; // 调用的对象

16.一般来说,所有类方法都将this指针设置为调用它的对象的地址。所以,以上代码,如下书写,是正确的吗?为什么?

const Stock& Stock::topval(const Stock& s) const 
    if (s.total_val > this->total_val)// 其中,“this->”可缺省
        return s;
    else
        return *this;

17.this是对象的地址,还是对象本身?
18.对象能创建数组吗?同常规数组相比,用法有什么不一样的吗?
19.看如下代码,花括号中的构造函数创建的是临时对象吗?创建10个元素,结果只初始化了3个,其余的元素默认是什么?这时就必须得为类提供什么构造函数了?

const int STKS = 10;
Stock stocks[STKS] = 
    Stock("NanoSmart", 12.5, 10),
    Stock();
    Stock("Monolithic Obelisks", 130, 3.25)
;

20.如下代码,可行吗?“声明类只是描述了对象的形式,决不能创建类数据成员”,所以,根本原因是什么?

class Bakery 
private:
    const int Months = 12;// 本身这句代码是不报错没问题的
    double costs[Months];// Error:a nonstatic member reference must be relative to a specific object

21.以上代码的替代方案有哪两种?第一种是?为什么可行?第二种是?为什么可行?
22.以下3种枚举分别有什么不同的含义?

enum RED, GREEN, BLUE;
--------------------------------------------
enum egg Small, Medium, Large, Jumbo;
enum t_shirt Small, Medium, Large, Xlarge;// Error!冲突!因为egg(Small)与t_shirt(Small)位于相同的作用域内。
--------------------------------------------
enum class egg Small, Medium, Large, Jumbo;
enum class t_shirt Small, Medium, Large, Xlarge;// OK!避免了上述问题,因为枚举量的作用域为类。
############################################
#include<iostream>
enum egg_old Small《mysql必知必会》笔记-部分

HIVE 必知必会

面试必知必会|理解堆和堆排序

必知必会的设计原则——合成复用原则

MySQL必知必会 第7-9章

SQL必知必会(第五版)