- 进程间通信方式
管道(有名管道,无名管道),共享内存,消息队列,信号量,socket通信
- 线程同步方式
临界区:通过对多线程的串行化来访问公共资源或一段代码,速度快,适合控制数据访问
互斥量:为协调共同对一个共享资源的单独访问而设计
信号量(PV操作):为控制一个具有有限数量用户资源而设计
事件:用来通知线程有一些事件已
- 进程和线程的区别
资源:进程是拥有资源的一个独立单位,线程是不拥有资源。
调度:线程作为调度和分配的基本单位,进程是作为资源的基本单位
并发性:进程之间可以有并发性进行,同一个进程中的多个线程是可以并发执行
系统开销:进程在创建和撤销的时候,由于系统要分配和回收资源,导致系统的开销明显大于线程
一个进程可以拥有多个线程。
- 局部变量和全局变量能否重名
能,局部屏蔽全局。在C++里使用全局,需要使用”::”。在C语言里,extern
- 虚函数和纯虚函数的区别
虚函数必须实现,纯虚函数没有实现
虚函数在子类里可以不重载,但是纯虚函数必须在每一个子类里去实现
在动态内存分配的时候,析构函数必须是虚函数,但没有必要是纯虚函数
- 面向对象的三大特性(四大特性)
封装、继承、多态(抽象)
封装:把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让可信的类或者对象操作,对不可信的进行信息隐藏
继承:子类可以拥有父类的属性和方法,但父类没有子类的属性和方法
多态:允许将子类类型的指针赋值给父类类型的指针
实现多态,有二种方式,覆盖,重载
覆盖,是指子类重新定义父类的虚函数的做法
重载,是指允许存在多个同名函数,而这些函数的参数表不同(或许参数个数不同,或许参数类型不同,或许两者都不同)
- vi编辑器打开时跳到指定的行
vi +5000 filename
- int型在Touble C里占多少个字节
2个字节
- 判断一个单链表是否有环
两个指针指向链表头,一个指针每次走一步,另一个指针每次走两步,若有一个指针先指向为NULL表示这个链表无环。若两个指针重合表示链表有环
- 刷新缓冲区方式?
换行刷新缓冲区
printf(“ ”);
使用函数刷新缓冲区
fflush(stdout);
程序结束刷新缓冲区
return 0;
- 类和对象的两个基本概念什么?
对象就是对客观事物在计算机中的抽象描述。
类就是对具体相似属性和行为的一组对象的统一描述。
类的包括:类说明和类实现两大部分:
类说明提供了对该类所有数据成员和成员函数的描述。
类实现提供了所有成员函数的实现代码。
- 数据库三范式
第一范式:没有重复的列
第二范式:非主属的部分依赖于主属部分
第三范式:属性部分不依赖于其他非主属部分
- ASSERT( )是干什么用的
是在调试程序使用的一个宏,括号里面要满足,如果不满足,程序将报告错误,并将终止执行。
- 如果只想让程序有一个实例运行,不能运行两个。像winamp一样,只能开一个窗口,怎样实现?
用内存映射或全局原子(互斥变量)、查找窗口句柄
FindWindow,互斥,写标志到文件或注册表,共享内存
- 如何截取键盘的响应,让所有的’a’变成’b’?
键盘钩子SetWindowsHookEx
- 网络编程中设计并发服务器,使用多进程 与 多线程 ,请问有什么区别?
1.进程:子进程是父进程的复制品。子进程获得父进程数据空间、堆和栈的复制品。
2.线程:相对与进程而言,线程是一个更加接近与执行体的概念,它可以与同进程的其他线程共享数据,但拥有自己的栈空间,拥有独立的执行序列。
两者都可以提高程序的并发度,提高程序运行效率和响应时间。
线程和进程在使用上各有优缺点:线程执行开销小,但不利于资源管理和保护;而进程正相反。同时,线程适合于在SMP机器上运行,而进程则可以跨机器迁移。
编程
字符串实现
strcat
char *strcat(char *strDes, const char *strSrc)
{
assert((strDes != NULL) && (strSrc !=NULL));
char *address = strDes;
while (*strDes != ‘ ′)
++ strDes;
while ((*strDes ++ = *strSrc ++) != ‘ ′)
NULL;
return address;
}
strncat
char *strncat(char *strDes, const char *strSrc,int count)
{
assert((strDes != NULL) && (strSrc !=NULL));
char *address = strDes;
while (*strDes != ‘ ′)
++ strDes;
while (count — && *strSrc != ‘ ′ )
*strDes ++ = *strSrc ++;
*strDes = ‘ ′;
return address;
}
strcmp
int strcmp(const char *s, const char *t)
{
assert(s != NULL && t != NULL);
while (*s && *t && *s == *t)
{
++ s;
++ t;
}
return (*s – *t);
}
strncmp
int strncmp(const char *s, const char *t, intcount)
{
assert((s != NULL) && (t != NULL));
while (*s && *t && *s == *t&& count –)
{
++ s;
++ t;
}
return (*s – *t);
}
strcpy
char *strcpy(char *strDes, const char *strSrc)
{
assert((strDes != NULL) && (strSrc !=NULL));
char *address = strDes;
while ((*strDes ++ = *strSrc ++) != ‘ ′)
NULL;
return address;
}
strncpy
char *strncpy(char *strDes, const char *strSrc,int count)
{
assert(strDes != NULL && strSrc !=NULL);
char *address = strDes;
while (count — && *strSrc != ‘ ′)
*strDes ++ = *strSrc ++;
return address;
}
strlen
int strlen(const char *str)
{
assert(str != NULL);
int len = 0;
while (*str ++ != ‘ ′)
++ len;
return len;
}
strpbrk
char *strpbrk(const char *strSrc, const char*str)
{
assert((strSrc != NULL) && (str !=NULL));
const char *s;
while (*strSrc != ‘ ′)
{
s = str;
while (*s != ‘ ′)
{
if (*strSrc == *s)
return (char *) strSrc;
++ s;
}
++ strSrc;
}
return NULL;
}
strstr
char *strstr(const char *strSrc, const char*str)
{
assert(strSrc != NULL && str != NULL);
const char *s = strSrc;
const char *t = str;
for (; *t != ‘ ′; ++ strSrc)
{
for (s = strSrc, t = str; *t != ‘ ′ &&*s == *t; ++s, ++t)
NULL;
if (*t == ‘ ′)
return (char *) strSrc;
}
return NULL;
}
strcspn
int strcspn(const char *strSrc, const char*str)
{
assert((strSrc != NULL) && (str !=NULL));
const char *s;
const char *t = strSrc;
while (*t != ‘ ′)
{
s = str;
while (*s != ‘ ′)
{
if (*t == *s)
return t – strSrc;
++ s;
}
++ t;
}
return 0;
}
strspn
int strspn(const char *strSrc, const char *str)
{
assert((strSrc != NULL) && (str !=NULL));
const char *s;
const char *t = strSrc;
while (*t != ‘ ′)
{
s = str;
while (*s != ‘ ′)
{
if (*t == *s)
break;
++ s;
}
if (*s == ‘ ′)
return t – strSrc;
++ t;
}
return 0;
}
strrchr
char *strrchr(const char *str, int c)
{
assert(str != NULL);
const char *s = str;
while (*s != ‘ ′)
++ s;
for (– s; *s != (char) c; — s)
if (s == str)
return NULL;
return (char *) s;
}
strrev
char* strrev(char *str)
{
assert(str != NULL);
char *s = str, *t = str, c;
while (*t != ‘ ′)
++ t;
for (– t; s < t; ++ s, — t)
{
c = *s;
*s = *t;
*t = c;
}
return str;
}
strnset
char *strnset(char *str, int c, int count)
{
assert(str != NULL);
char *s = str;
for (; *s != ‘ ′ && s – str <count; ++ s)
*s = (char) c;
return str;
}
strset
char *strset(char *str, int c)
{
assert(str != NULL);
char *s = str;
for (; *s != ‘ ′; ++ s)
*s = (char) c;
return str;
}
strtok
char *strtok(char *strToken, const char *str)
{
assert(strToken != NULL && str !=NULL);
char *s = strToken;
const char *t = str;
while (*s != ‘ ′)
{
t = str;
while (*t != ‘ ′)
{
if (*s == *t)
{
*(strToken + (s – strToken)) = ‘ ′;
return strToken;
}
++ t;
}
++ s;
}
return NULL;
}
strupr
char *strupr(char *str)
{
assert(str != NULL);
char *s = str;
while (*s != ‘ ′)
{
if (*s >= ‘a’ && *s <= ‘z’)
*s -= 0×20;
s ++;
}
return str;
}
strlwr
char *strlwr(char *str)
{
assert(str != NULL);
char *s = str;
while (*s != ‘ ′)
{
if (*s >= ‘A’ && *s <= ‘Z’)
*s += 0×20;
s ++;
}
return str;
}
memcpy
void *memcpy(void *dest, const void *src, intcount)
{
assert((dest != NULL) && (src !=NULL));
void *address = dest;
while (count –)
{
*(char *) dest = *(char *) src;
dest = (char *) dest + 1;
src = (char *) src + 1;
}
return address;
}
memccpy
void *memccpy(void *dest, const void *src, intc, unsigned int count)
{
assert((dest != NULL) && (src !=NULL));
while (count –)
{
*(char *) dest = *(char *) src;
if (* (char *) src == (char) c)
return ((char *)dest + 1);
dest = (char *) dest + 1;
src = (char *) src + 1;
}
return NULL;
}
memchr
void *memchr(const void *buf, int c, int count)
{
assert(buf != NULL);
while (count –)
{
if (*(char *) buf == c)
return (void *) buf;
buf = (char *) buf + 1;
}
return NULL;
}
memcmp
int memcmp(const void *s, const void *t, intcount)
{
assert((s != NULL) && (t != NULL));
while (*(char *) s && *(char *) t&& *(char *) s == *(char *) t && count –)
{
s = (char *) s + 1;
t = (char *) t + 1;
}
return (*(char *) s – *(char *) t);
}
memmove
void *memmove(void *dest, const void *src, intcount)
{
assert(dest != NULL && src != NULL);
void *address = dest;
while (count –)
{
*(char *) dest = *(char *) src;
dest = (char *) dest + 1;
src = (const char *)src + 1;
}
return address;
}
memset
void *memset(void *str, int c, int count)
{
assert(str != NULL);
void *s = str;
while (count –)
{
*(char *) s = (char) c;
s = (char *) s + 1;
}
return str;
}
strdup
char *strdup(const char *strSrc)
{
assert(strSrc != NULL);
int len = 0;
while (*strSrc ++ != ‘ ′)
++ len;
char *strDes = (char *) malloc (len + 1);
while ((*strDes ++ = *strSrc ++) != ‘ ′)
NULL;
return strDes;
}
strchr_
char *strchr_(char *str, int c)
{
assert(str != NULL);
while ((*str != (char) c) && (*str !=‘ ′))
str ++;
if (*str != ‘ ′)
return str;
return NULL;
}
strchr
char *strchr(const char *str, int c)
{
assert(str != NULL);
for (; *str != (char) c; ++ str)
if (*str == ‘ ′)
return NULL;
return (char *) str;
}
atoi
int atoi(const char* str)
{
int x=0;
const char* p=str;
if(*str==’-’||*str==’+’)
{
str++;
}
while(*str!=0)
{
if((*str>’9′)||(*str<’0′))
{
break;
}
x=x*10+(*str-’0′);
str++;
}
if(*p==’-’)
{
x=-x;
}
return x;
}
itoa
char* itoa(int val,char* buf,unsigned intradix)
{
char *bufptr;
char *firstdig;
char temp;
unsigned int digval;
assert(buf != NULL);
bufptr = buf;
if (val < 0)
{
*bufptr++ = ‘-’; val = (unsignedint)(-(int)val);
}
firstdig = bufptr;
do
{
digval =(unsigned int) val % radix; val /=radix;
if (digval > 9)
{
*bufptr++ = (char)(digval – 10 + ‘a’);
}
else
{
*bufptr++ = (char)(digval + ’0′);
}
} while(val > 0);
*bufptr– = ‘ ′;//设置字符串末尾,并将指针指向最后一个字符
do //反转字符
{
temp = *bufptr; *bufptr = *firstdig; *firstdig= temp;
–bufptr; ++firstdig;
} while(firstdig < bufptr);
return buf;
}
String实现
已知String原型为:
class String
{
public:
//普通构造函数
String(const char *str =NULL)
//拷贝构造函数
String(const String&other)
//析构函数
~String(void);
//赋值函数
String &operator=(String &other) //oh,原题目打错了,string可是一个关键字
private:
char* m_str;
unsigned m_uCount;
};
分别实现以上四个函数
//普通构造函数
String::String(const char* str)
{
if(str==NULL) //如果str为NULL,存空字符串
{
m_str= new char[1]; //分配一个字节
*m_str=‘ ′; //赋一个’ ′
}else
{
m_str= new char[strlen(str) + 1];//分配空间容纳str内容
strcpy(m_str,str); //复制str到私有成员m_str中
}
}
//析构函数
String::~String()
{
if(m_str!=NULL) //如果m_str不为NULL,释放堆内存
{
delete[] m_str;
m_str= NULL;
}
}
//拷贝构造函数
String::String(const String &other)
{
m_str = new char[strlen(other.m_str)+1]; //分配空间容纳str内容
strcpy(m_str,other.m_str); //复制other.m_str到私有成员m_str中
}
//赋值函数
String & String::operator=(String&other)
{
if(this ==&other) //若对象与other是同一个对象,直接返回本身
{
return*this
}
delete []m_str; //否则,先释放当前对象堆内存
m_str = newchar[strlen(other.m_str)+1]; //分配空间容纳str内容
strcpy(m_str,other.m_str); //复制other.m_str到私有成员m_str中
return *this;
}
编写一个二分查找的功能函数
int BSearch(elemtype a[],elemtype x,int low,inthigh)
/*在下届为low,上界为high的数组a中折半查找数据元素x*/
{
int mid;
if(low>high)
return -1;
mid=(low+high)/2;
if(x==a[mid])
return mid;
if(x<a[mid])
return(BSearch(a,x,low,mid-1));
else
return(BSearch(a,x,mid+1,high));
}
2) 非递归方法实现:
int BSearch(elemtype a[],keytype key,int n)
{
int low,high,mid;
low=0;high=n-1;
while(low<=high)
{
mid=(low+high)/2;
if(a[mid].key==key)
return mid;
else if(a[mid].key<key)
low=mid+1;
else
high=mid-1;
}
return -1;
}
字符串逆序
方法一
#include <stdio.h>
#include <string.h>
void main()
{
charstr[]=”hello,world”;
int len=strlen(str);
char t;
int i;
for(i=0; i<len/2;i++)
{
t=str[i];
str[i]=str[len-i-1];
str[len-i-1]=t;
}
printf(“%s ”,str);
return 0;
}
方法二
#include <stdio.h>
int main(){
char* src = “hello,world”;
int len = strlen(src);
char* dest =(char*)malloc(len+1);//要为