2015年蓝桥杯省赛B组C/C++（试题+答案）
时间： 19:13:47
&&&& 阅读：38617
&&&& 评论：
&&&& 收藏：1
标签：首先说，这次我是第二次参加蓝桥杯（大学里最后一次），可这次去连个三等都没拿到，有些心灰意冷，比上一次还差，
当时看到成绩出来的时候有些失落，但是跌倒了，再站起来继续跑就可以了。可能是状态不好吧，纯属自我安慰。
接下来我把今年的题目又重新做了一遍，写下了这篇博客，如果也有需要探讨答案的，希望可以有帮助。
第1题：统计不含4的数字
　　统计1中，不包含4的数值个数。
解题分析：　&&&
第一种解法：
&&&&& 数学方法，这种是在网上看到的一种解法：
　　最高位除了0、4不能使用，其余8个数字（1,2,3,5,6,7,8,9）均能使用，剩下的四位（千位、百位、十位、个位）
&&&&&&&& 可以使用除了4以外的所有数字，所以共有 8*9*9*9*9种解，
&&&&&&& 计算得答案为：52488。
第二种解法：
&&&&& 暴力搜索方法，这个数字的位数共有5位因此，可以设置a, b, c, d, e,分别代表这5位。
#include &iostream&
#include &cstdio&
int main()
&& &&& &int a, b, c, d,
&& &&& &int count = 0;
&& &&& &for(a = 1; a &= 9; a++)
&& &&& &&& &&& &for(b = 0; b &= 9; b++)
&& &&& &&& &&& &{
&& &&& &&& &&& &&& &&& &for(c = 0; c &= 9; c++)
&& &&& &&& &&& &&& &&& &{
&& &&& &&& &&& &&& &&& &&& &&& &for(d = 0; d &= 9; d++)
&& &&& &&& &&& &&& &&& &&& &&& &{
&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &for(e = 0; e &= 9; e++)
&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &{
&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &if(a != 4 && b != 4 && c != 4 && d != 4 && e !=4)
&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &{
&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &count++;
&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &}
&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &
&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &}
&& &&& &&& &&& &&& &&& &&& &&& &
&& &&& &&& &&& &&& &&& &&& &&& &}
&& &&& &&& &&& &&& &&& &
&& &&& &&& &&& &&& &&& &}
&& &&& &&& &&& &
&& &&& &&& &&& &}
&& &&& &cout&&count&&
&& &&& &return 0;
输出为：&&& 52488
第2题：计算1千天后的日期
　　再过1000天是哪一日？
解题分析：
我想这里题目，对于大家来说分析的时候难点就在于那年是闰年，那年是平年
那么从年之间2016年是闰年，因此这一年就是365天，
这道题，我是手算的。
重点是要按照格式提交。
第3题：竖式加法
　　祥 瑞 生 辉
　　三 羊 献 瑞
　三 羊 生 瑞 气
题目用了8个不同的汉字，表示0~9里八种不同的数字。组成两个数值相加，等于第三个数值。
求三羊献瑞”对应到数字是多少？
解题分析：
第一种暴力搜索：
我假设结果中进位的是1，那么三对应的就是数字1.
接下来定义变量。
&&& a b c d
+ 1& e& f& b
------------------
&1 e c b g
这段代码输三个结果，把每个结果带进去试一下就知道那个是了。
#include &iostream&
#include &cstdio&
int main()
&& &int a, b, c, d, e, f,
&& &for(a = 1; a &= 9; a++)
&& &&& &for(b = 0; b &= 9; b++)
&& &&& &&& &for(c = 0; c &= 9; c++)
&& &&& &&& &{
&& &&& &&& &&& &for(d = 0; d &= 9; d++)
&& &&& &&& &&& &{
&& &&& &&& &&& &&& &&& &for(e = 0; e &= 9; e++)
&& &&& &&& &&& &&& &&& &{
&& &&& &&& &&& &&& &&& &&& &for(f = 0; f &= 9; f++)
&& &&& &&& &&& &&& &&& &&& &{
&& &&& &&& &&& &&& &&& &&& &&& &for(g = 0; g &= 9; g++)
&& &&& &&& &&& &&& &&& &&& &&& &{
&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &if((a * 1000 + b * 100 + c * 10 + d) + (1000 + e * 100 + f * 10 + b) == (10000 + e * 1000 + c * 100 + b * 10 + g))
&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &{
&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &if(a != 1 && b != 1 && c != 1 && d != 1 && e != 1 && f != 1)
&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &{
&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &if(a != b && a != c && a != d && a !=e && a != f && a != g && b != c && b != d && b != e && b != f && b != g && c != d && c != e && c != f && c != g && d != e && d != f && d != g && e != f && e != g && f !=
&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &{
&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &cout&&1 * 1000 + e * 100 + f * 10 + b&&
&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &}
&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &
&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &}
&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &}
&& &&& &&& &&& &&& &&& &&& &&& &
&& &&& &&& &&& &&& &&& &&& &&& &}
&& &&& &&& &&& &&& &&& &&& &}
&& &&& &&& &&& &&& &&& &}
&& &&& &&& &&& &
&& &&& &&& &&& &}
&& &&& &&& &}
&& &return 0;
第二种解法：
全排列方法：
#include &iostream&
#include &cstdio&
#include &algorithm&
int main()
&& &int a[10];
&& &for(int i = 0; i &= 9; i++)
&& &&& &&& &a[i] =
&& &&& &if(!a[2] || !a[6])
&& &&& &&& &&& &
&& &&& &int x = a[2] * 1000 + a[3] * 100 + a[4] * 10 + a[5];
&& &&& &int y = a[6] * 1000 + a[7] * 100 + a[8] * 10 + a[3];
&& &&&& int z = a[6] * 10000 + a[7] * 1000 + a[4] * 100 + a[3] * 10 + a[9];
&& &&& &if(x + y == z)
&& &&& &&& &cout &&y&&&& &
&& &}while(next_permutation(a, a + 10));
&& &return 0;
=======================================================================================
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& 代码填空
=======================================================================================
第4题：古怪的星号修饰符
　　是道代码填空题，主要是完成一个字符串s，按宽度width截断后，在固定宽度为width，两边为符号’|’的居中输出。
　　难点是题目给出了printf(“%*s%s%*s”,___)，要求填printf的实参列表。
这道题看的时候觉得有点坑，因为自己不懂printf(&%*s %s %*s&, );;的意思，我开始还以为是指针那一块的。
现在把网上的给大家分享：
有些童鞋可能知道scanf里用*修饰符，是起到过滤读入的作用。比如一个有三列数值的数据，我只想得到第2列数值，可以在循环里用scanf(“%*d%d%*d”, a[i])来读入第i行的第2个数值到a[i]。
　　* 修饰符在printf中的含义完全不同。如果写成printf(“%6d”, 123)，很多童鞋应该就不会陌生了，这是设置域宽的意思。同理，%6s也是域宽。* 修饰符正是用来更灵活的控制域宽。使用%*s，表示这里的具体域宽值由后面的实参决定，如printf(“%*s”, 6, “abc”)就是把”abc”放到在域宽为6的空间中右对齐。
　　明白了 * 是用变量来控制域宽，那么这题就简单了，这里应该填写5个实参。然后字符长度的计算应该用buf而不是s，因为buf才是截断后的长度，用s的话，如果s长度超过了width-2，效果就不对了。
类似使用说明的代码如下：
#include &iostream&
#include &cstdio&
#include &cstring&
int main() {
&&& char s[100] = &abcd1234&;
&&& char buf[1000];
&&& int width = 20;
&&& strcpy(buf, s);
&&& buf[width-2] = 0;
&&& printf(&|%*s%s%*s|\n&, (width-strlen(buf)-2)/2, &&, buf, (width-strlen(buf)-2)/2, &&);
&&& return 0;
第5题：补充全排列的回溯算法
　　1,2,3…9 这九个数字组成一个分数，其值恰好为1/3，如何组法？
与第3题一样可以用全排列暴力，但这题是代码填空题，且已经手写一部分全排列算法，我们负责补充其中一行代码。
　　写全排就是用回溯的思想，直接猜到for循环里的第三行，应该就是把第一行的交换操作再交换回来~~复制for里的第一行代码，运行下程序，还不放心就调试下，看看数组是不是有按字典序在变化就行了。
　　答案：{t=x[k]; x[k]=x[i]; x[i]=t;}
======================================================================================&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& 填空
=======================================================================================
第6题：加号改乘号
　　把1+2+3+…+48+49中的两个加号改成乘号（修改位置不能相邻），使得式子的结果由1225变为2015。
解题分析：
用双循环暴力两个乘号的位置，计算在数字i、j后的加号改为乘号，式子数值的变化即可，注意j的起始位置为i+2。
#include &iostream&
#include &cstdio&
int main()
&& &for(int i = 1; i &= 48; i++)
&& &&& &&& &for(int j = i + 2; j &= 48; j++)
&& &&& &&& &{
&& &&& &&& &&& &&& &if(1225 - i - (i + 1) - j - (j + 1) == 2015 - i * (i + 1) - j * (j + 1))
&& &&& &&& &&& &&& &&& &&& &cout&&i&&
&& &&& &&& &}
&& &return 0;
第7题：牌型种数
小明被劫持到X赌城，被迫与其他3人玩牌。
一副扑克牌（去掉大小王牌，共52张），均匀发给4个人，每个人13张。
这时，小明脑子里突然冒出一个问题：
如果不考虑花色，只考虑点数，也不考虑自己得到的牌的先后顺序，自己手里能拿到的初始牌型组合一共有多少种呢？
请填写该整数，不要填写任何多余的内容或说明文字。
解题分析：
&&&&&&& 这里也是两种方法， 暴力搜索， 动态规划（ＤＰ）。
&& 第一种：
暴力方法：
#include &iostream&
#include &cstdio&
int main()
&& &int a[13];&& &
&& &int ans = 0;
&& &for(a[0]=0; a[0]&=4; a[0]++)
&& &&& &for(a[1]=0; a[1]&=4; a[1]++)
&& &&& &&& &for(a[2]=0; a[2]&=4; a[2]++)
&& &&& &&& &{
&& &&& &&& &&& &for(a[3]=0; a[3]&=4; a[3]++)
&& &&& &&& &&& &{
&& &&& &&& &&& &&& &for(a[4]=0; a[4]&=4; a[4]++)
&& &&& &&& &&& &&& &{
&& &&& &&& &&& &&& &&& &for(a[5]=0; a[5]&=4; a[5]++)
&& &&& &&& &&& &&& &&& &{
&& &&& &&& &&& &&& &&& &&& &for(a[6]=0; a[6]&=4; a[6]++)
&& &&& &&& &&& &&& &&& &&& &{&& &
&& &&& &&& &&& &&& &&& &&& &&& &for(a[7]=0; a[7]&=4; a[7]++)
&& &&& &&& &&& &&& &&& &&& &&& &{
&& &&& &&& &&& &&& &&& &&& &&& &&& &for(a[8]=0; a[8]&=4; a[8]++)
&& &&& &&& &&& &&& &&& &&& &&& &&& &{
&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &for(a[9]=0; a[9]&=4; a[9]++)
&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &{
&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &for(a[10]=0; a[10]&=4; a[10]++)
&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &{
&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &for(a[11]=0; a[11]&=4; a[11]++)
&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &{
&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &for(a[12]=0; a[12]&=4; a[12]++)
&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &{
&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &if(a[0]+a[1]+a[2]+a[3]+a[4]+a[5]+a[6]+a[7]+a[8]+a[9]+a[10]+a[11]+a[12]==13)
&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &{
&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &count++;
&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &ans =
&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &}
&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &}
&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &}
&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &}
&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &}
&& &&& &&& &&& &&& &&& &&& &&& &&& &}
&& &&& &&& &&& &&& &&& &&& &&& &}
&& &&& &&& &&& &&& &&& &&& &}
&& &&& &&& &&& &&& &&& &}&& &
&& &&& &&& &&& &&& &}
&& &&& &&& &&& &}
&& &&& &&& &}
&& &cout&&ans&&
&& &return 0;
具体参考：
http://blog.csdn.net/u/article/details/
动态规划，　DP。
假设牌是从1到13按顺序取的，dp[i][j]表示取到第i号的牌，目前总共有j张牌的取法总数，那么有状态转移方程（注意公式没考虑边界处理）：
　　如图：
#include &iostream&
#include &cstdio&
typedef long long LL;
LL dp[14][14]; // dp[i][j]: 当前到第i张牌，总共有j张牌时的解的个数
int main() {
&&& dp[1][0] = dp[1][1] = dp[1][2] = dp[1][3] = dp[1][4] = 1;
&&& for (int i = 2; i &= 13; i++) {
&&&&&&& for (int k = 0; k &= 13; k++) {
&&&&&&&&&&& if (k - 4 &= 0) dp[i][k] += dp[i-1][k-4];
&&&&&&&&&&& if (k - 3 &= 0) dp[i][k] += dp[i-1][k-3];
&&&&&&&&&&& if (k - 2 &= 0) dp[i][k] += dp[i-1][k-2];
&&&&&&&&&&& if (k - 1 &= 0) dp[i][k] += dp[i-1][k-1];
&&&&&&&&&&& dp[i][k] += dp[i-1][k];
&&& cout && dp[13][13] &&
&&& return 0;
第8题：计算房子间曼哈顿距离
　　房子按S形摆放，如
　　7 8 ……
　　现输入每行的宽度w，计算出任意两个房子m、n的曼哈顿距离（横向距离+竖向距离）。
解题分析：
直接计算两点的距离就可以了。
#include &iostream&
#include &cstdio&
#include &cmath&
Fun(int w, int n, int& x, int& y)
&& &&& &x = (n - 1) / w + 1;
&& && &&& &y = n %&& &
&& &&& &if(y == 0)
&& &&& &&& &&& &y =
&& &&& &if(x % 2 == 0)
&& &&& &&& &&& &y = w - y + 1;
int main()
&& &&& &int w, m,
&& &&& &int x1, y1, x2, y2;
&& &&& &cin&&w&&m&&n;
&& &&& &Fun(w, m, x1, y1);
&& &&& &Fun(w, n, x2, y2);
&& &&& &cout&&abs(x1 - x2) + abs(y1 - y2)&&
&& &&& &return 0;
第9题：垒骰子(矩阵快速幂模)
　　 输入n,m，表示用n个骰子，在m个约束条件下，从下往上叠成一列。接下来m行，每行有两个数a,b，表示骰子之间数字a、b两个所在面不能拼接。
　　 问这n个骰子一共有多少种垒法？答案对1e9+7取余。
注意骰子摆好后，四个方向均能转动，即样例输入：
　　 2　 1
　　 1　 2
的样例输出是：
矩阵快速幂基础
　　请读者先看这篇文章：，或阅读其他矩阵快速幂模文章，自行补基础。我给出的这篇文章，写了个矩阵快速幂模的类模板，将在下面的代码中使用。实际解题中，可以根据特殊问题写特殊代码，不必写出通用的矩阵类，加快解题速度。
　　比赛中，不使用模板，建议数组从下标1开始使用。这里为了和模板配合，所以假设骰子从0开始编号。可以发现规律，如果骰子的a面为0,1,2，那么a的对面数值就是a+3；相反，如果骰子的a面为3,4,5，那么a的对面数值就是a-3。这个由当前面变换到对面的操作可以用公式完成：(a+3)%6。
　　现在用一个bool数组isLimit[6][6]来存储，isLimit[i][j]为真，代表当前骰子i面朝上，不能接j面朝上的骰子。
　　矩阵快速幂模，主要是找到A^(n-1) * X中的A和X。那么这里的X向量，X[i]初值就是第一个骰子i面朝上的方法数，一共是4种。即X[0]~X[5]均为4。
　　A[i][j]就是当前骰子i面朝上，接j面朝上后，原方法数要乘上的因子。故A[i][j]可以由isLimit直接得到。如果i-&j被限制，乘因子就是0，否则就是4。
#include &algorithm&
#include &cstring&
#include &iostream&
/*矩阵类（用于快速幂模）
1、T是整型类型，N是方阵大小，MOD是取余的值
2、Eye是单位阵
template &typename T, const int N, const int MOD&
class Matrix {
T val[N][N];
Matrix() { memset(val, 0, sizeof(val)); }
Matrix(T a[N][N]) { memcpy(val, a, sizeof(val)); }
Matrix operator*(const Matrix& c) const {
for (int i = 0; i & N; ++i)
for (int j = 0; j & N; ++j)
for (int k = 0; k & N; ++k) {
res.val[i][j] += val[i][k] * c.val[k][j];
//防止矩阵元素变为负数，若不需要，去掉&+MOD&
res.val[i][j] = (res.val[i][j] + MOD) % MOD;
Matrix& operator*=(const Matrix& c) {
*this = *this *
Matrix operator^(int k) const { //返回*this^k
Matrix res = Eye();
Matrix step(*this);
while (k) {
if (k & 1) res *=
Matrix Eye() const {
for (int i = 0; i & N; i++) a.val[i][i] = 1;
void out() const {
for (int i = 0; i & N; i++) {
for (int j = 0; j & N; j++)
cout && val[i][j] && & &;
cout && &\n&;
T* operator[](int i) { return val[i]; }
typedef long long LL;
const int MOD = 1e9 + 7;
int main() {
Matrix&LL,6,MOD& A, X, Y;
bool isLimit[6][6];
// 输入处理
cin && n &&
memset(isLimit, false, sizeof(isLimit));
for (int i = 0; i & i++) {
cin && a &&
isLimit[a-1][ (b+2)%6 ] =
isLimit[b-1][ (a+2)%6 ] =
// 初始化A
for (int i = 0; i & 6; i++) {
for (int j = 0; j & 6; j++) {
A[i][j] = (!isLimit[i][j]) * 4;
// 初始化X
for (int i = 0; i & 6; i++) X[i][0] = 4;
// 计算Y及答案
Y = (A^(n-1)) * X;
LL sum = 0;
for (int i = 0; i & 6; i++) sum += Y[i][0];
cout && sum % MOD &&
第10题：树形DP
　　在一颗树中，每个点都有一个权值，有正有负。
　　要求找一个连通的点集S，使得累加和最大。
　　树形DP不是我熟悉的模块，这个坑就交给别人填了。
　　树形DP参考博客：，及下方提供的代码：
#include&iostream&
#include&algorithm&
#include&cstdio&
#include&vector&
typedef long long LL;
const int MAXN=;10;
const int INF=-;
LL dp[MAXN][2];
vector&int&tree[MAXN];
LL w[MAXN];
void dfs(int p,int fa){
dp[p][0]=max(dp[p][0],w[p]);
dp[p][1]=max(dp[p][1],w[p]);
for(int i=0;i&tree[p].size();i++){
int son=tree[p][i];
if(son^fa){
dfs(son,p);
dp[p][0]=max(dp[p][0],dp[son][0]);
if(dp[son][1]&0)dp[p][1]+=dp[son][1];
dp[p][0]=max(dp[p][0],dp[p][1]);
int main(){
int n,a,b;
for(int i=1;i&=n;i++)cin&&w[i];
for(int i=1;i&=n;i++){dp[i][0]=INF;dp[i][1]=INF;}
for(int i=1;i&n;i++){
cin&&a&&b;
tree[a].push_back(b);
tree[b].push_back(a);
dfs(1,-1);
cout&&dp[1][0]&&&\n&;
标签：原文地址：http://blog.csdn.net/u/article/details/
&&国之画&&&& &&&&chrome插件&&
版权所有 京ICP备号-2
迷上了代码！一，某次面试被问的题1.进程间通信的方式进程间通信就是在不同进程之间传播或交换信息，进程的用户空间是互相独立的，一般而言是不能互相访问的，唯一的例外是共享内存区。但是，系统空间却是“公共场所”，所以内核显然可以提供这样的条件。除此以外，那就是双方都可以访问的外设了。在这个意义上，两个进程当然也可以通过磁盘上的普通文件交换信息，或者通过“注册表”或其它数据库中的某些表项和记录交换信息。广义上这也是进程间通信的手段，但是一般都不把这算作“进程间通信”。因为那些通信手段的效率太低了，而人们对进程间通信的要求是要有一定的实时性。详细的参考 http://blog.csdn.net/chenxun_2010/article/details/2.指针和引用的区别在C和C++中，指针一般指的是某块内存的地址，通过这个地址，我们可以寻址到这块内存；而引用是一个变量的别名，例如我们给小明起了个外号：明明，那我们说明明的时候，就是说小明。对于指针来说，它是一个地址，这个地址是一个数值，那么就意味这个数值可以为0(空指针)，也可以为其他，即指针可以不指向任何东西。int a = 0;
int b = 1;
int *point = NULL;
point = &a;
// 在某个时刻，指针可以指向a
point = &b; 而对于引用来说，他是一个外号，外号一定是“某个存在物体”的外号，所以引用不能为空，即不能存在空引用。而引用则不同，引用只能在初始化的时候就赋好值，之后就不能改变了，用外号的例子来说就是"明明"这个外号在出现的时候就是代指小明，之后“明明”这个外号就绑在小明身上了，它不能过段时间换成小暗的外号。int xiaoming = 1;
int &refence_mingming =
int xiaoan = 2;
refence_mingming =
// error,引用不能换了根据以上可知指针和引用的一个重要不同：指针可以为空，引用不能为空。这就意味着我们拿到一个引用的时候，是不需要判断引用是否为空的，而拿到一个指针的时候，我们则需要判断它是否为空。这点经常在判断函数参数是否有效的时候使用。总结为：
1. 指针是一个变量，只不过这个变量存储的是一个地址，指向内存的一个存储单元；而引用是变量的一个别名，内部实现是只读指针
2. 引用使用时无需解引用(*)，指针需要解引用；
3. 引用只能在初始化时被赋值，其他时候值不能被改变，指针的值可以在任何时候被改变
4. 引用没有 const，指针有 const；
5. 引用不能为空，指针可以为空；
6. “sizeof 引用”得到的是所指向的变量(对象)的大小，而“sizeof 指针”得到的是指针本身的大小；
7. 指针和引用的自增(++)运算意义不一样；
8. 指针可以有多级，但是引用只能是一级（int **p；合法 而 int &&a是不合法的）
9.从内存分配上看：程序为指针变量分配内存区域，而引用不需要分配内存区域。
10.引用可以取地址操作，返回的是被引用变量本身所在的内存单元地址
11.引用使用在源代码级相当于普通的变量一样使用，做函数参数时，内部传递的实际是变量地址3.用递归方式把左二叉树变成右二叉树http://www.leoox.com/?p=1034。冒泡排序5、请用简单的语言告诉我C++ 是什么？C和C++的区别？C++是在C语言的基础上开发的一种面向对象编程语言，应用广泛。C++支持多种编程范式 －－面向对象编程、泛型编程和过程化编程。支持类：类、封装、重载等特性!c++在c的基础上增添类，C是一个结构化语言，它的重点在于算法和数据结构。C程序的设计首要考虑的是如何通过一个过程，对输入（或环境条件）进行运算处理得到输出（或实现过程（事务）控制），而对于C++，首要考虑的是如何构造一个对象模型，让这个模型能够契合与之对应的问题域，这样就可以通过获取对象的状态信息得到输出或实现过程（事务）控制。6：什么是面向对象（OOP）？答：面向对象是一种对现实世界理解和抽象的方法、思想，通过将需求要素转化为对象进行问题处理的一种思想。7：面向对象的三个基本特征，并简单叙述之？一、封装：封装是实现面向对象程序设计的第一步，封装就是将数据或函数等集合在一个个的单元中（我们称之为类）。封装的意义在于保护或者防止代码（数据）被我们无意中破坏。二、继承：广义的继承有三种实现形式：实现继承（指使用基类的属性和方法而无需额外编码的能力）、可视继承（子窗体使用父窗体的外观和实现代码）、接口继承（仅使用属性和方法，实现滞后到子类实现）。前两种（类继承）和后一种（对象组合=&接口继承以及纯虚函数）构成了功能复用的两种方式。继承主要实现重用代码，节省开发时间。子类可以继承父类的一些东西。三、多态多态：多态是指相同的操作或函数、过程可作用于多种类型的对象上并获得不同的结果。不同的对象，收到同一消息可以产生不同的结果，这种现象称为多态。在运行时，可以通过指向基类的指针，来调用实现派生类中的方法。8：类的static变量在什么时候初始化？函数的static变量在什么时候初始化？答：类的静态成员变量在类实例化之前就已经存在了，并且分配了内存。函数的static变量在执行此函数时进行初始化。9. 关键字static的作用
1.函数体内 static 变量的作用范围为该函数体，不同于 auto 变量， 该变量的内存只被分配一次，因此其值在下次调用时仍维持上次的值
2.在模块内的 static 全局变量可以被模块内所有函数访问，但不能被模块外其他函数访问
3.在模块内的static 函数只可被这一模块内的其他函数调用，这个函数的使用范围被限制在声明它的模块内
4.在类的static 成员变量属于整个类所拥有，对类的所以对象只有一份拷贝
在类中的 static 成员函数属于整个类所拥有，这个函数不接收 this 指针，因而只能访问类的 static 成员变量
介绍它最重要的一条：隐藏。（static函数，static变量均可） --& 对应上面的2、3项。当同时编译多个文件时，所有未加static前缀的全局变量和函数都具有全局可见性。10. 什么时候要用虚析构函数
通过基类的指针来删除派生类的对象时，基类的析构函数应该是虚的。否则其删除效果将无法实现。一般情况下，这样的删除只能够删除基类对象，而不能删除子类对象，形成了删除一半形象，从而千万内存泄漏。
原因：在公有继承中，基类对派生类及其对象的操作，只能影响到那些从基类继承下来的成员。如果想要用基类对非继承成员进行操作，则要把基类的这个操作（函数）定义为虚函数。那么，析构函数自然也应该如此：如果它想析构子类中的重新定义或新的成员及对象，当然也应该声明为虚的。
注意：如果不需要基类对派生类及对象进行操作，则不能定义虚函数（包括虚析构函数），因为这样会增加内存开销。11.一些小知识点(1) .头文件中的 ifndef/define/endif 干什么用？预处理答：防止头文件被重复引用(2). ＃include 和 ＃include “filename.h” 有什么区别？答：前者用来包含开发环境提供的库头文件，后者用来包含自己编写的头文件。(3).在C++ 程序中调用被 C 编译器编译后的函数，为什么要加 extern “C”声明？答：函数和变量被C++编译后在符号库中的名字与C语言的不同，被extern “C”修饰的变量和函数是按照C语言方式编译和连接的。由于编译后的名字不同，C++程序不能直接调用C 函数。C++提供了一个C 连接交换指定符号extern“C”来解决这个问题。（5）程序的局部变量存在于（堆栈）中，全局变量存在于（静态区 ）中，动态申请数据存在于（ 堆）中。（6）队列和栈有什么区别？ 　　 　　队列先进先出，栈后进先出（7）软件测试都有那些种类? 　黑盒：针对系统功能的测试 　　白盒：测试函数功能，各函数接口12.C++中为什么用模板类。答：(1)可用来创建动态增长和减小的数据结构（2）它是类型无关的，因此具有很高的可复用性。（3）它在编译时而不是运行时检查数据类型，保证了类型安全（4）它是平台无关的，可移植性（5）可用于基本数据类型13.C++中什么数据分配在栈或堆中，New分配数据是在近堆还是远堆中？答：栈: 存放局部变量，函数调用参数,函数返回值，函数返回地址。由系统管理堆: 程序运行时动态申请，new 和　malloc申请的内存就在堆上 14.什么是预编译，何时需要预编译：答: 就是指程序执行前的一些预处理工作,主要指#表示的.何时需要预编译?１)、总是使用不经常改动的大型代码体。 ２)、程序由多个模块组成，所有模块都使用一组标准的包含文件和相同的编译选项。在这种情况下，可以将所有包含文件预编译为一个预编译头。15.局部变量能否和全局变量重名？
答：能，局部会屏蔽全局。要用全局变量，需要使用"::" ;局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全 局变量。对于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局部变量，而那个局部变量的作用域就在那个 循环体内。16.如何引用一个已经定义过的全局变量？ 1　　答：extern 　可以用引用头文件的方式，也可以用extern关键字，如 果用引用头文件方式来引用某个在头文件中声明的全局变理，假定你将那个编写错了，那么在编译期间会报错，如果你用extern方式引用时，假定你犯了同样 的错误，那么在编译期间不会报错，而在连接期间报错。17.全局变量可不可以定义在可被多个.C文件包含的头文件中？为什么？ 答：可以，在不同的C文件中以static形式来声明同名全局变量。 　　可以在不同的C文件中声明同名的全局变量，前提是其中只能有一个C文件中对此变量赋初值，此时连接不会出错. 18.static全局变量与普通的全局变量有什么区别？static局部变量和普通局部变量有什么区别？static函数与普通函数有什么区别？ 　　答: 1) 全 局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。全局变量本身就是静态存储方式， 静态全局变量当然也是静态存储方式。 这两 者在存储方式上并无不同。这两者的区别在于非静态全局变量的作用域是整个源程序， 当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是 有效的。 而静态全局变量则限制了其作用域， 即只在定义该变量的源文件内有效， 在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限 于一个源文件内，只能为该源文件内的函数公用， 因此可以避免在其它源文件中引起错误。 　　2) 从以上分析可以看出， 把局部变量改变为静态 变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域，限制了它的使用范围。　 　
19. 下述三个有什么区别？char *char const * pconst char *p解答：char * //常量指针，p的值不可以修改char const * p；//指向常量的指针，指向的常量值不可以改const char *p； //和char const *p1.
c指针int *p[n];-----指针数组，每个元素均为指向整型数据的指针。int (*p)[n];------p为指向一维数组的指针，这个一维数组有n个整型数据。int *p();----------函数带回指针，指针指向返回的值。int (*p)();------p为指向函数的指针。 请问C++的类和C里面的struct有什么区别？答:c++中的类具有成员保护功能，并且具有继承，多态这类oo特点，而c里的struct没有 c里面的struct没有成员函数,不能继承,派生等等.20.struct 和 class 的区别答案：struct 的成员默认是公有的，而类的成员默认是私有的。struct 和 class 在其他方面是功能相当的。21.简述数组与指针的区别？数组要么在静态存储区被创建（如全局数组），要么在栈上被创建。指针可以随时指向任意类型的内存块。(1)修改内容上的差别char a[] = “hello”;a[0] = ‘X’;char *p = “world”; // 注意p 指向常量字符串p[0] = ‘X’; // 编译器不能发现该错误，运行时错误(2) 用运算符sizeof 可以计算出数组的容量（字节数）。sizeof(p),p 为指针得到的是一个指针变量的字节数，而不是p 所指的内存容量。C++/C 语言没有办法知道指针所指的内存容量，除非在申请内存时记住它。注意当数组作为函数的参数进行传递时，该数组自动退化为同类型的指针。22、子类析构时要调用父类的析构函数吗？析构函数调用的次序是先派生类的析构后基类的析构，也就是说在基类的的析构调用的时候 , 派生类的信息已经全部销毁了定义一个对象时先调用基类的构造函数、然后调用派生类的构造函数；析构的时候恰好相反：先调用派生类的析构函数、然后调用基类的析构函数
无析构函数深拷贝和浅拷贝23. 全局变量和局部变量有什么区别？是怎么实现的？操作系统和编译器是怎么知道的？答;全局变量的生命周期是整个程序运行的时间，而局部变量的生命周期则是局部函数或过程调用的时间段。其实现是由编译器在编译时采用不同内存分配方法。全局变量在main函数调用后，就开始分配，静态变量则是在main函数前就已经初始化了。局部变量则是在用户栈中动态分配的（还是建议看编译原理中的活动记录这一块）24、 多态的作用？1）隐藏实现细节，使得代码能够模块化；扩展代码模块，实现代码重用；2）接口重用，为了类在继承和派生的时候，保证使用家族中任一类的实例的某一属性时的正确调用。25. 类成员函数重载和重写(覆盖）和隐藏的区别？常考的题目。从定义上来说：重载：是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。重写：是指子类重新定义父类虚函数的方法。从实现原理上来说：重载：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。如，有两个同名函数：function func(p:integer):和function func(p:string):。那么编译器做过修饰后的函数名称可能是这样的：int_func、str_func。对于这两个函数的调用，在编译器间就已经确定了，是静态的。也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！重写：和多态真正相关。当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚绑定）。a.成员函数被重载的特征：（1）相同的范围（在同一个类中）；（2）函数名字相同；（3）参数不同；（4）virtual 关键字可有可无。b.覆盖是指派生类函数覆盖基类函数，特征是：（1）不同的范围（分别位于派生类与基类）；（2）函数名字相同；（3）参数相同；（4）基类函数必须有virtual 关键字。c.“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下：（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual 关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）26、继承优缺点。类继承是在编译时刻静态定义的，且可直接使用，类继承可以较方便地改变父类的实现。但是类继承也有一些不足之处。首先，因为继承在编译时刻就定义了，所以无法在运行时刻改变从父类继承的实现。更糟的是，父类通常至少定义了子类的部分行为，父类的任何改变都可能影响子类的行为。如果继承下来的实现不适合解决新的问题，则父类必须重写或被其他更适合的类替换。这种依赖关系限制了灵活性并最终限制了复用性。27：常用的排序算法有哪些？简单描述几个排序算法的优缺点？答：选择、冒泡、快速、**、希尔、归并、堆排等。1.快排：是冒泡排序的一种改进。优点：快，数据移动少缺点：稳定性不足2.归并：分治法排序，稳定的排序算法，一般用于对总体无序，但局部有序的数列。优点：效率高O(n)，稳定缺点：比较占用内存28：堆和栈的区别？堆和栈的生命周期？
一、堆栈空间分配区别：1、栈（操作系统）：由操作系统自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈；2、堆（操作系统）： 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收，分配方式倒是类似于链表。
二、堆栈缓存方式区别：1、栈使用的是一级缓存， 他们通常都是被调用时处于存储空间中，调用完毕立即释放；2、堆是存放在二级缓存中，生命周期由虚拟机的垃圾回收算法来决定（并不是一旦成为孤儿对象就能被回收）。所以调用这些对象的速度要相对来得低一些。
三、堆栈数据结构区别：堆（数据结构）：堆可以被看成是一棵树，如：堆排序；栈（数据结构）：一种先进后出的数据结构。29：解释C++中静态函数和静态变量？(1)类静态数据成员在编译时创建并初始化：在该类的任何对象建立之前就存在，不属于任何对象，而非静态类成员变量则是属于对象所有的。类静态数据成员只有一个拷贝，为所有此类的对象所共享。(2)类静态成员函数属于整个类，不属于某个对象，由该类所有对象共享。1、static 成员变量实现了同类对象间信息共享。2、static 成员类外存储，求类大小，并不包含在内。3、static 成员是命名空间属于类的全局变量，存储在 data 区的rw段。4、static 成员只能类外初始化。5、可以通过类名访问（无对象生成时亦可），也可以通过对象访问。1、静态成员函数的意义，不在于信息共享，数据沟通，而在于管理静态数据成员，完成对静态数据成员的封装。2、静态成员函数只能访问静态数据成员。原因：非静态成员函数，在调用时 this指针时被当作参数传进。而静态成员函数属于类，而不属于对象，没有 this 指针。30：什么是内存泄漏？面对内存泄漏和指针越界，你有哪些方法？你通常采用哪些方法来避免和减少这类错误？答：用动态存储分配函数动态开辟的空间，在使用完毕后未释放，结果导致一直占据该内存单元即为内存泄露。使用的时候要记得指针的长度。malloc的时候得确定在那里free.对指针赋值的时候应该注意被赋值指针需要不需要释放.动态分配内存的指针最好不要再次赋值.31.程序什么时候应该使用线程，什么时候单线程效率高。答：1．耗时的操作使用线程，提高应用程序响应2．并行操作时使用线程，如C/S架构的服务器端并发线程响应用户的请求。3．多CPU系统中，使用线程提高CPU利用率4．改善程序结构。一个既长又复杂的进程可以考虑分为多个线程，成为几个独立或半独立的运行部分，这样的程序会利于理解和修改。其他情况都使用单线程。 【持续更新中。。】