C++

按照数据结构类型的不同，将数据模型划分为层次模型、网状模型和关系模型。

cvs （ Concurrent Version System ） 是一个版本控制系统。可以记录下你的源文件的历史。

事务处理系统的特点：ACID 指的是 Atomic （原子的）、 Consistent （一致的）、 Isolated （隔离的）以及 Durable （持续的）。

四个特征：原子性：组成事务处理的语句形成了一个逻辑单元，不能只执行其中的一部分；一致性：在事务处理执行之前和之后，数据是一致的；隔离性：一个事务处理对另一个事务处理没有影响；持续性：当事务处理成功执行到结束的时候，其效果在数据库中被永久纪录下来。

由于 malloc/free 是库函数而不是运算符，不在编译器控制权限之内，不能够把执行构造函数和析构函数的任务强加于 malloc/free 

c/c++是编译型语言，还有一些语言完全是解释型的（如Basie），而java既是编译型的又是解释型的语言
c/c++存在指针运算，Basie没有显示指针，而java有指针，但取消了指针的运算

类继承是在编译时刻静态定义的，且可直接使用，类继承可以较方便地改变父类的实现。但也无法在运行时刻改变从父类继承的实现。

封装是利用可重用成分构造软件系统的特性，它不仅支持系统的可重用性，而且还有利于提高系统的可扩充性；消息传递可以实现发送一个通用的消息而调用不同的方法；封装是实现信息隐蔽的一种技术，其目的是使类的定义和实现分离。

多态是具有表现多种形态的能力的特征，在OO中是指，语言具有根据对象的类型以不同方式处理之，特别是重载方法和继承类这种形式的能力。多态性是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说：允许将子类类型的指针赋值给父类类型的指针。多态性在Object Pascal和C++中都是通过虚函数（Virtual Function） 实现的。继承是子类使用父类的方法，而多态则是父类使用子类的方法。这是一句，多态从用法上就是要用父类(确切的说是父类的对象名)去调用子类的方法。

数据库Mysql怎么获得系统时间？select now();//输出当前数据库时间select sysdate();//输出系统时间select curdate(); select curtime();

Oracle怎么获得系统时间？select to_char(sysdate,'yyyy-mm-dd hh24:mi:ss') from dual;to_char(sysdate, 'Q')--季to_char(sysdate, 'iw')--周

--获取11月天数--select to_char(last_day(to_date('2010-11-1','YYYY-MM-DD'))，'DD') from dual;

--时间间隔乘以一个数字，8个七小时select sysdate,sysdate - 8*interval '7' hour from dual;

读取目录下所有文件的方法？读取目录下所有子目录下文件的方法？

#include <dirent.h>
struct dirent
{
   long d_ino; /* inode number 索引节点号 */
   off_t d_off; /* offset to this dirent 在目录文件中的偏移 */
   unsigned short d_reclen; /* length of this d_name 文件名长 */
   unsigned char d_type; /* the type of d_name 文件类型 */
   char d_name [NAME_MAX+1]; /* file name (null-terminated) 文件名，最长255字符 */
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <dirent.h>
#include <unistd.h>
int readFileList(char *basePath)
{
    DIR *dir;
    struct dirent *ptr;
    char base[1000];

    if ((dir=opendir(basePath)) == NULL)
    {
        perror("Open dir error...");
        exit(1);
    }

    while ((ptr=readdir(dir)) != NULL)
    {
        if(strcmp(ptr->d_name,".")==0 || strcmp(ptr->d_name,"..")==0)    ///current dir OR parrent dir
            continue;
        else if(ptr->d_type == 8)    ///file
            printf("d_name:%s/%s\n",basePath,ptr->d_name);
        else if(ptr->d_type == 10)    ///link file
            printf("d_name:%s/%s\n",basePath,ptr->d_name);
        else if(ptr->d_type == 4)    ///dir
        {
            memset(base,'\0',sizeof(base));
            strcpy(base,basePath);
            strcat(base,"/");
            strcat(base,ptr->d_name);
            readFileList(base);
        }
    }
    closedir(dir);
    return 1;
}

int main(void)
{
    DIR *dir;
    char basePath[1000];

    ///get the current absoulte path
    memset(basePath,'\0',sizeof(basePath));
    getcwd(basePath, 999);
    printf("the current dir is : %s\n",basePath);

    ///get the file list
    memset(basePath,'\0',sizeof(basePath));
    strcpy(basePath,"./XL");
    readFileList(basePath);
    return 0;
}

Linux/Unix下读取指定目录下的所有文件名

#include <iostream>
#include "apue.h"
#include <dirent.h>
using namespace std;

int main(int argc, char * argv[])
{
    DIR *dp;
    struct dirent *dirp;
    if (argc != 2) 
    {
        err_quit("Usage: ls directory_name");
    }
    
    //打开指定的目录
    if ((dp = opendir(argv[1])) == NULL)
    {
        err_sys("can't open %s", argv[1]);
    }
    
    //遍历目录
    while ((dirp = readdir(dp)) != NULL)
    {
        printf("%s\n", dirp->d_name);
    }
    
    //关闭目录
    closedir(dp);
    return 0;
}

heap area存放程序的动态数据；stack area存放程序的局部数据

1、栈区（stack）— 由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。地址是由高向低减少的
2、堆区（heap） — 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，地址是由低向高增长的。

3、全局区（静态区）（static）：全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和静态变量在相邻的另一块区域。程序结束后由系统释放。4、文字常量区：常量字符串就是放在这里的，程序结束后由系统释放。5、程序代码区：存放函数体的二进制代码。

（1）stack的空间由操作系统自动分配/释放，heap上的空间手动分配/释放。（2）stack空间有限，heap是很大的自由存储区。（3）C中的malloc函数分配内存空间即在堆上，C++中对应的是new操作符。（4）程序在编译期对变量和函数分配内存都在栈上进行，且程序运行过程中函数调用时参数的传递也在栈上进行。

比较两数中较大

a,b 都要定义成 unsigned long：c = a*(1-(a-b)>>31)+b*(1-(b-a)>>31);

a,b 都要定义成 long：c = -(a*(1-(a-b)>>31)+b*(1-(b-a)>>31));

c = (fabs(a-b)+a+b)/2.0;

c = (((x-y)>>(sizeof(x-y)*8-1)&1)*y) + (((y-x)>>(sizeof(y-x)*8-1)&1)*x);

c = a>b ? a,b;

 

整数转换成字符串数

#include <iostream>
using namespace std;
//不使用itoa函数
int main ()
{
    int num =12345,i=0,j=0;
    char temp[7],str[7];
    while(num)
    {
        temp[i]=num%10+'0'; //将整数num从后往前的每一位数转换成char保存在temp中
        i++; num=num/10;
    }
    temp[i]=0;
    cout<<"temp:"<<temp<<endl;
    i=i-1;
    //反转temp
    while (i>=0)
    { str[j++]=temp[i--]; }
    str[j]=0;
    cout<<"string:"<<str<<endl;
    return 0;
}

//使用itoa函数
int main ()
{
    int num=12345;
    char str[7];
 
    itoa(num,str,10);
    cout<<"integer:"<<num<<endl<<"string:"<<str<<endl;
    return 0;
}

不调用C++/C的字符串库函数，请编写strcpy函数，还要char *类型返回值？

char *strcpy(char *strDest,const char *strSrc)
{
    assert((strDest!=NULL)&&(strSrc!=NULL));
    char *address=strDest;
    while((*strDest++=*strSrc++)!='\0')
    NULL;
    return address;
}
Because：
int length=strlen(strcpy(strDest,"hello world"));

" abcdefghi “，如果n=2，移位后应该是 “hiabcdefg ”

void LoopMove(char *pStr,int steps)
{
    int n=strlen(pStr)-steps;
    char temp[MAX_LEN];
    strcpy(temp,pStr+n);
    strcpy(temp+steps,pStr);
    *(temp+strlen(pStr))=‘\0’;
    strcpy(pStr,temp);
}

出现的相同且长度最长的字符串，输出它及其首字符的位置。例如：“yyabcdabjcabceg”，输出结果应该为 abc和 3。

int main ()
{
    string str,tep;
    cout<<"请输入字符串：";
    cin>>str;
 
    for(int i=str.length()-1;i>1;i--)
    {
        for(int j=0;j<str.length();j++)
        {
            if(j+i<=str.length())
            {
                size_t t=0;
                size_t num=0;
                tep=str.substr(j,i);//从大到小去字串
                t=str.find(tep);    //正序查找
                num=str.rfind(tep); //逆序查找
                if(t!=num)          //如果两次查找的位置不一致说明存在重复
                {
                    cout<<tep<<" "<<t+1<<endl;
                    return 0;
                }
            }
        }
    }
    return 0;
}

i come from beijing.倒置后变成：beijing. from come i

#include <iostream>
using namespace std;
 
int main ()
{
    int num=-12345,i=0,j=0,flag=0,begin,end;
    char str[]="i come from beijing.";
    char temp;
    j=strlen(str)-1;
    //第一步是进行全盘翻转
    while(j>i)
    {
        temp=str[i];
        str[i++]=str[j];
        str[j--]=temp;
    }
    //第二步进行部分翻转
    i=0;
    while(str[i])
    {
        if(str[i]!=' ')
        {
            begin=i;
            while(str[i] && str[i]!=' ')
                i++;  //找到str[i]为空格符
            i=i-1;    //空格符回退一个
            end=i;
        }
        while(end>begin) //部分翻转
        {
            temp=str[begin];
            str[begin++]=str[end];
            str[end--]=temp;
        }
        i++; 
    }
    cout<<"string:"<<str<<endl;
}

用两个栈实现一个队列的功能，请用C++实现。

#include<iostream>
#include<stack>
using namespace std;
 
template<class T>
struct Queue
{
    void push(T &t)
    {        s1.push(t);    }
 
    T front()
    {
        if(s2.empty())
        {
            if(s1.size()==0)throw;
            while(!s1.empty())
            {  s2.push(s1.top()); s1.pop(); }
        }
        return s2.top();
    }
 
    void pop()
    {
        if(s2.empty())
        {
            while(!s1.empty())
            { s2.push(s1.top()); s1.pop(); }
        }
        if(!s2.empty())
            s2.pop();
    }
    stack<T> s1;
    stack<T> s2;
}

编程实现队列的入队/出队操作。

#include<iostream>
using namespace std;
 
typedef struct student
{
    int data;
    struct student *next;
}node;
 
typedef struct linkqueue
{
    node *first,*rear;
}queue;
 
//队列的入队
queue *insert(queue *HQ,int x)
{
    node *s;
    s=(node *)malloc(sizeof(node));
    s->data=x;
    s->next=NULL;
    if(HQ->rear==NULL)
    {  HQ->first=s; HQ->rear=s;  }
    else
    {  HQ->rear->next=s; HQ->rear=s; }
    return (HQ);
}
 
//队列的出队
queue *remove(queue *HQ)
{
    node *p;
    if(HQ->first==NULL)
        printf("\n yichu");
    else
    {
        p=HQ->first;
        if(HQ->first==HQ->rear)
        { HQ->first=NULL; HQ->rear=NULL; }
        else
        { HQ->first=HQ->first->next; free(p); }
        return (HQ);
    }
}

已知n个人（以编号1，2，3，...，n分别表示）围坐在一张圆桌周围，从编号为k的人开始报数，数到m的那个人出列，他的下一个人又从k开始报数，数到m的那个人出列，依次重复下去，直到圆桌的人全部出列。约瑟夫环问题的实际场景

#include<iostream>
using namespace std;
 
typedef struct LNode
{
    int data;
    struct LNode *link;
}LNode,*LinkList;
 
//n为总人数，k为第一个开始报数的人，m为出列者喊到的数
void JOSEPHUS(int n,int k,int m)
{
    //p为当前节点，r为辅助节点，指向p的前驱节点，list为头节点
    LinkList p,r,list,curr;
    //简历循环链表
    p=(LinkList)malloc(sizeof(LNode));
    p->data=1;
    p->link=p;
    curr=p;
    for(int i=2;i<=n;i++)
    {
        LinkList t=(LinkList)malloc(sizeof(LNode));
        t->data=i;
        t->link=curr->link;
        curr->link=t;
        curr=t;
    }
    //把当前指针移动到第一个报数的人
    r=curr;
    while(k--)
        r=p,p=p->link;
    while(n--)
    {
        for(int s=m-1;s--;r=p,p=p->link);
        r->link=p->link;
        printf("%d->",p->data);
        free(p);
        p=r->link;
    }
}