1-编写String类的构造函数、析构函数、和赋值函数
已知String的原型为：
class String
{
public:
String(const char *str=NULL);//构造函数
String(const String &other);//拷贝构造函数
~String();//析构函数
String& operator=(const String &other);//赋值函数
private:
char* m_data;//用于保存字符串
};
//-----------构造函数
String::String(const char* str)
{
if(str==NULL)
{
m_data=new char[1];
*m_data='/0';
}
else
{
int length=strlen(str);
m_data=new char[length+1];
strcpy(m_data,str);
}
}
//---------拷贝构造函数
String::String(const String &other)
{
int length=strlen(other.m_data);
m_data=new char[length+1];
strcpy(m_data,other.m_data);
}
//--------赋值函数
String& String::operator=(const String &other)
{
//检查自赋值
if(this==&other)
return *this;
//释放原有的内存资源
delete []m_data;
//分配新的内存资源，并复制内容
int length=strlen(other.m_data);
m_data=new char[length+1];
strcpy(m_data,other.m_data);
//返回本对象的引用
return *this；
}
//--------析构函数
String::~String()
{
delete []m_data;
}
2-实现双向列表删除一个节点p，在节点p后插入一个节点，写出这两个函数。
void DeleteNode(Node* p)
{
p->prior->next=p->next;
p->next->prior=p->prior;
}
void InsertNode(Node* p , Node* s)
{
s->next=p->next;
p->next->prior=s;
p->next=s;
s->prior=p;
}
3-Windows程序的入口是哪里？写出Windows消息机制的流程。
Windows程序的入口时WinMain函数
消息机制的流程：
系统中发生了某个事件，Windows把这个事件翻译为消息，然后把它放在消息队列中
a.应用程序从消息队列中接收到这个消息，把它放在Msg结构中
b.应用程序把消息传递给一个适当的窗口过程
c.窗口过程相应这个消息并进行处理
4-编写strcpy函数
#include <iostream.h>
#include <string.h>
#include <malloc.h>
#include <assert.h>
char* strcpy(char* strDest,char* strSrc)
{
assert( (strDest!=NULL) && (strSrc!=NULL) );
char *address=strDest;
while( *strSrc!='/0')
*strDest++ = *strSrc++;
return address;
}
该函数返回char*类型的返回值是为了实现链式表达式
例如：int length=strlen(strcpy(strDest , "Hello World!"));
void main()
{
char str1[]="123456";
char str2[]="abcdefghijklmn";
strcpy(str2,str1);
cout<<str2<<endl;
}
5-写一个函数，将其中的/t都转换成4个空格
char* Convert_t(char* des,char* src)
{
char* temp;
des=new char[100];
temp=des;
while(*src!='/0')
{
if(*src=='/t')
{
src++;
*des++=' ';
*des++=' ';
*des++=' ';
*des++=' ';
continue;
}
*des++=*src++;
}
*des='/0';
des=temp;
return des;
}
void main()
{
char* t="asdf/tasd/tasasddas//tdfasdf" , *d=NULL;
cout<<t<<endl;
cout<<Convert_t(d,t)<<endl;
}6-如何定义和实现一个类的成员函数为回调函数
如果类的成员函数是一个callback函数，必须宣告它为static，才能把c++编译器加诸于函数的一个隐藏参数this去掉。
7-C++里面是不是所有的动作都是main()引起的？如果不是，请举例。
不是的，例如：全局对象的实例化，全局变量的动态空间申请等等，例如
char* des=new char[100];
void main()
{
char* des="abc";
cout<<des<<endl;
}
//全局变量的动态空间申请在程序运行之后，main运行之前完成。所以，不是所有的动作都是main引起的。
8-编写一个函数，作用是把一个char组成的字符串循环右移n个。比如原来是“abcdefghi”，如果n=2，移位后应该是“hiabcdefg”。
方法1
void LoopMove(char* pStr , int steps)
{
int n=strlen(pStr)-steps;
char tmp[100];
strcpy(tmp,pStr+n);
strcpy(tmp+steps,pStr);
*( tmp+strlen(pStr) )='/0';
strcpy(pStr,tmp);
}
方法2
void LoopMove(char* pStr , int steps)
{
int n=strlen(pStr)-steps;
char tmp[100];
memcpy(tmp,pStr+n,steps);
memcpy(pStr+steps,pStr,n);
memcpy(pStr,tmp,steps);
}
9-写出输出结果
void fun(char s[10])//只是告诉函数参数为一数组
{
char a[10];
cout<<"a:"<<sizeof(a)<<endl;
cout<<"s:"<<sizeof(s)<<endl;
}
输出结果：a:10
s:4;
10-内存的分配方式有几种？
1、从静态存储器分配。内存在程序编译的时候就分配好，这块内存在程序的整个运行期间都存在，例如：全局变量。
2、在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。
3、从堆上分配，亦称动态内存分配。程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负责在何时用free或delete释放内存。动态内存的生存期由我们决定，使用灵活，但问题较多。
11-static有什么用途？
1）在函数体内，一个被声明为静态的变量在这一函数被调用的过程中维持其值不变。
2）在模块内(但在函数体外)，一个被声明为静态的变量可以被模块内所有函数访问，但不能被模块外其他函数访问。它是一个本地的全局变量。
3）在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是，这个函数被限制在声明它的模块的本地范围内使用。
12-引用与指针有什么区别？
1）引用必须被初始化，指针不必
2）引用初始化以后不能被改变，指针可以改变所指的对象
3）不存在指向空间的引用，但是存在指向空间的指针
补充说明引用：引用就是某个变量的别名，对引用的操作与对变量直接操作效果完全相同，声明一个引用的时候，切记要对其进行初始化。引用声明完毕后，相当于目标变量有两个名称，即该目标原名称和引用名。不能再把该引用名作为其它变量的别名。声明一个引用不是定义了一个新的变量，它只表示该引用名是目标变量的一个别名，它本身不是一种数据类型，因此引用本身不占存储单元，系统也不给引用分配存储单元。不能建立数组的引用。
引用作为函数参数的特点：
1）传递引用给函数与传递指针效果是一样的。这时，被调函数的形参 成为 主调函数中实参变量或对象的一个别名来使用，所以在被调函中对形参变量的操作就是对其相应的目标对象(在主调函数中)的操作。
2）使用 引用 传递函数的参数，在内存中并没有产生实参的副本，它是直接对实参操作；而使用一般变量传递函数的参数，当发生函数调用时，需要给形参分配存储单元，形参变量是实参变量的副本；如果传递的是对象，还要将调用对象的拷贝构造函数，因此，当参数传递的数据较大时，用 引用 比用 一般变量 传递参数的效率和所占空间都好。
3）使用指针作为函数的参数虽然也能达到与使用引用相同的效果。但是在被调函数中同样要给形参分配存储单元，且需要重复使用
“*指针变量名”的形式进行运算，这很容易产生错误且程序的阅读性较差；另一方面，在主调函数的调用点处，必须用变量的地址作为实参。而引用更容易使用，更清晰。
4）如果既要使用引用提高程序的效率，又要保护传递给函数的数据不在函数中被改变，就应使用常引用。常引用声明方式：
const 类型标示符 &引用名=目标变量名；int a ; const int &ra=a;
13-单向链表的反转
单向链表的反转是一个经常被问到的一个面试题，也是一个非常基础的问题。比如一个链表是这样的： 1->2->3->4->5 通过反转后成为5->4->3->2->1。
最容易想到的方法遍历一遍链表，利用一个辅助指针，存储遍历过程中当前指针指向的下一个元素，然后将当前节点元素的指针反转后，利用已经存储的指针往后面继续遍历。源代码如下：
struct linka
{
int data;
linka* next;
};
void reverse(linka*& head)
{
if(head ==NULL)
return;
linka *pre, *cur, *ne;
pre=head;
cur=head->next;
while(cur)
{
ne = cur->next;
cur->next = pre;
pre = cur;
cur = ne;
}
head->next = NULL;
head = pre;
}
14-面向对象的三个基本特征，并简单叙述之？
1） 封装：将客观事物抽象成类，每个类对自身的数据和方法实行protection(private, protected,public)
2.）继承：广义的继承有三种实现形式：实现继承（指使用基类的属性和方法而无需额外编码的能力）、可视继承（子窗体使用父窗体的外观和实现代码）、接口继承（仅使用属性和方法，实现滞后到子类实现）。前两种（类继承）和后一种（对象组合=>接口继承以及纯虚函数）构成了功能复用的两种方式。
3） 多态：是将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。
15- 重载（overload)和覆盖(overried)的区别？
常考的题目。从定义上来说：
重载：是指允许存在多个同名函数，而这些函数的参数表不同（发生在同一个类中，或许参数个数不同，或许参数类型不同，或许两者都不同）
覆盖：是指子类重新定义父类虚函数的方法。
从实现原理上来说：
重载：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。如，有两个同名函数： function func(p:integer):integer;和function func(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的：int_func、str_func。对于这两个函数的调用，在编译器间就已经确定了，是静态的。也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！
覆盖：和多态真正相关。当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚绑定）。
16-类内部常量成员变量和静态成员变量的初始化
class student
{
public:
student();
const int data;
static int xx;
};
int student::xx=6;
student::student():data(5)
{
}
void main()
{
student stu;
cout<<stu.data<<endl;
cout<<stu.xx<<endl;
}
17-main 函数执行以前，还会执行什么代码？
答案：全局对象的构造函数会在main 函数之前执行。
18-描述内存分配方式以及它们的区别?
1） 从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static 变量。
2） 在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈 内存分配运算 内置于 处理器的指令集。
3） 从堆上分配，亦称动态内存分配。程序在运行的时候用malloc 或new 申请任意多少的内存，程序员自己负责在何时用free 或delete 释放内存。动态内存的生存期由程序员决定，使用非常灵活，但问题也最多。
19-当一个类A 中没有生命任何成员变量与成员函数,这时sizeof(A)的值是多少，如果不是零，请解释一下编译器为什么没有让它为零
答案：不是零，是1。举个反例，如果是零的话，声明一个class A[10]对象数组，而每一个对象占用的空间是零，这时就没办法区分A[0],A[1]…了。
20-请说出const与#define 相比，有何优点？
答案：1） const 常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换，没有类型安全检查，并且在字符替换可能会产生意料不到的错误。
2） 有些集成化的调试工具可以对const 常量进行调试，但是不能对宏常量进行调试。
21-简述数组与指针的区别？
数组要么在静态存储区被创建（如全局数组），要么在栈上被创建。指针可以随时指向任意类型的内存块。
(1)修改内容上的差别
char a[] = “hello”;
a[0] = ‘X’;
char *p = “world”; // 注意p 指向常量字符串
p[0] = ‘X’; // 编译器不能发现该错误，运行时错误
(2) 用运算符sizeof 可以计算出数组的容量（字节数）。sizeof(p),p 为指针得到的是一个指针变量的字节数，而不是p 所指的内存容量。C++/C 语言没有办法知道指针所指的内存容量，除非在申请内存时记住它。注意当数组作为函数的参数进行传递时，该数组自动退化为同类型的指针。
char a[] = "hello world";
char *p = a;
cout<< sizeof(a) << endl; // 12 字节
cout<< sizeof(p) << endl; // 4 字节
计算数组和指针的内存容量
void Func(char a[100])
{
cout<< sizeof(a) << endl; // 4 字节而不是100 字节
}
22-类成员函数的重载、覆盖和隐藏区别？
a.成员函数被重载的特征：
（1）相同的范围（在同一个类中）；
（2）函数名字相同；
（3）参数不同；
（4）virtual 关键字可有可无。
b.覆盖是指派生类函数覆盖基类函数，特征是：
（1）不同的范围（分别位于派生类与基类）；
（2）函数名字相同；
（3）参数相同；
（4）基类函数必须有virtual 关键字。
c.“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下：
（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。
（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual 关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）
23-There are two int variables: a and b, don’t use “if”, “? :”, “switch”or other judgement statements, find out the biggest one of the two numbers.
答案：( ( a + b ) + abs( a - b ) ) / 2
24- 如何打印出当前源文件的文件名以及源文件的当前行号？
答案：
cout << __FILE__ ;
cout<<__LINE__ ;
__FILE__和__LINE__是系统预定义宏，这种宏并不是在某个文件中定义的，而是由编译器定义的。
38. 如何判断一段程序是由C 编译程序还是由C++编译程序编译的？
答案：
#ifdef __cplusplus
cout<<"c++";
#else
cout<<"c";
#endif
42. 写一个函数找出一个整数数组中，第二大的数 （microsoft）
答案：
const int MINNUMBER = -32767 ;
int find_sec_max( int data[] , int count)
{
int maxnumber = data[0] ;
int sec_max = MINNUMBER ;
for ( int i = 1 ; i < count ; i++)
{
if ( data[i] > maxnumber )
{
sec_max = maxnumber ;
maxnumber = data[i] ;
}
else
{
if ( data[i] > sec_max )
sec_max = data[i] ;
}
}
return sec_max ;
}
void main()
{
int shz[6]={2,5,1,8,9,3};
cout<<find_sec_max(shz,6)<<endl;
}
795
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
