7：编写类String的构造函数、析构函数和赋值函数，已知类String的原型为：
class String
{
public:
String(const char *str = NULL); // 普通构造函数
String(const String &other); // 拷贝构造函数
~ String(void); // 析构函数
String & operate =(const String &other); // 赋值函数
private:
char *m_data; // 用于保存字符串
};
String::String(const char *str = NULL)
{
if(str == NULL)
{
m_data = new char[1];
*m_data = '\0';
}
else
{
int len = strlen(str + 1);
m_data = new char[len];
strcpy(m_data,str);
}
}
String::~String(void)
{
delete []m_data;
}
String::String(const String &other)
{
m_data = new char[strlen(other.m_data)+1];
strcpy(m_data,other.m_data);
}
//赋值函数
String & String::operate =(const String &other) // 得分点：输入参数为const型
{
if(this == &other)
return(this);
delete m_data;
int len = strlen(other.m_data) + 1;
m_data = new char[len];
strcpy(m_data,other.m_data);
return this;
}
试题：写一个函数返回1+2+3+…+n的值（假定结果不会超过长整型变量的范围）
int sum(int n)
{
return(n*(n+long(1))/2);
}
}
1.将一个字符串逆序
#include <string.h>
/* reverse: reverse string s in place */
void reverse(char s[])
{
int c, i, j;
for (i = 0, j = strlen(s)-1; i < j; i++, j--)
c = s[i], s[i] = s[j], s[j] = c;
}
2.将一个链表（linked list）逆序
node *linkrev(node *head)
{
node *p1,*p2,*p3;
if(head||head->next)
return head;
p1 = head;
p2 = head->next;
while(p2)
{
p3 = p2->next;
p2->next = p1;
p1 = p2;
p2 = p3;
}
head->next = null;
head = p1;
return head;
}
3.计算一个字节（byte）里有多少bit被置1
算法一： a)要计算一个整数对应的二进制数有多少位是 1，常用的方法是使用位移：
int countone(int n)
{
int count;
int len = sizeof(n);
for(i=0,i<len,i++)
{
count += n&1;
n >>= 1;
}
return count;
}
算法二：
int count;
for(count = 0; x&=x--;count++);
算法三：查表法：
unsigned char mask[] = {1,2,4,8,16,32,64,128};
unsigned char val = 11;
unsigned char* p = mask;
int c = 0;
while(p < mask + 8)
{
if ( *p++ & val)
++c;
}
cout<<"num of 1's = " << c <<endl;
4.搜索给定的字节（byte）
5.在一个字符串中找到可能的最长的子字符串，该字符串是由同一字符组成的
6字符串转换成整数
/* atoi: convert s to integer */
int atoi(char s[])
{
int i, n;
n = 0;
for (i = 0; s[i] >= '0' && s[i] <= '9'; ++i)
n = 10 * n + (s[i] - '0');
return n;
}
7.整数转换成字符串（这个问题很不错，因为应试者要用到堆栈或者strev函数）
/* itoa: convert n to characters in s */
void itoa(int n, char s[])
{
int i, sign;
if ((sign = n) < 0) /* record sign */
n = -n; /* make n positive */
i = 0;
do { /* generate digits in reverse order */
s[i++] = n % 10 + '0'; /* get next digit */
} while ((n /= 10) > 0); /* delete it */
if (sign < 0)
s[i++] = '-';
s[i] = '\0';
reverse(s);
}
#include <string.h>
/* reverse: reverse string s in place */
void reverse(char s[])
{
int c, i, j;
for (i = 0, j = strlen(s)-1; i < j; i++, j--) {
c = s[i];
s[i] = s[j];
s[j] = c;
}
}
1。请实现一个类型，该类型只能在栈上分配，不能从堆上分配
2。请实现一个类型，该类型只能在堆上分配，不能从栈上分配
1。重载一个private的operator new
说明：new操作符变为私有，不能这样构造对象了：
CMyClass* pmyObj = new CMyClass(); // 堆上
只能这样：
CMyClass myObj；// 栈上
2。将ctor作为private,写一个public的static的CreateObject方法，在其中用new
创建object。
说明：ctor变为私有，不能这样构造对象了
CMyClass myObj；// 栈上
只能这样：
应该是：CMyClass* pmyObj = CMyClass::CreateObject();