C++基础知识点

红太狼 2022-08-12 12:59 151阅读 0赞

1 指针和引用的区别

1.指针是一个变量，里面存放的是地址，而引用则是原变量的一个别名；

2.可以由const指针，但是 没有const引用；

3.指针的值可以为NULL，但是应用不能为空，在初始化的时候必须要指定；

4.指针的值在初始化完成之后可以被改变，但是引用在初始化的之后不能被改变；

5.sizeof引用"得到的是所指向的变量(对象)的大小，而"sizeof指针"得到的是指针本身的大小；

6.指针和引用的++的意义不一样

2 memcpy和strcpy的区别

memcpy是用来内存的拷贝，需要指定长度，可以是任何的数据类型；

strcpy是用来拷贝字符串的，遇到‘/0’就会结束；

3 new，delete和malloc，free的区别

new和delete是C++的运算符，malloc和free是C、c++标准库的函数，用来申请内存和释放内存；对于非内部的数据类型对象，使用malloc和free不能满足要求。

因为在创建对象的时候，会调用对象的构造函数，在对象灭忙的时候，会调用对象的析构函数。但是由于malloc和free是库函数，编译器不能把执行构造函数和

析构函数的任务交给malloc和free；

4 struct和class的区别

1 成员变量的默认访问权限

struct的默认成员变量的权限是public，但是Class的是private。

2 存储顺序

struct的成员是按声明的顺序来存储的，但是Class确实不一定。

3 继承

对于继承，struct是public，而Class是private

5  union和struct的区别

1 union是所有的变量共用的一个内存区域，长度是由最大长度的那个变量决定；struct的变量时独立分配的。

2 union的变量时连续分配的，但是struct的变量不一定是连续的。

6 如何引用一个已经定义过的全局变量

可以用引入文件头的方式，也可以用extern的方式来引入。如果使用文件头的方式来引进一个在某个文件头声明的全局变量，如果全局变量写错，则是编译期间会出现错误；

如果是应用extern的方式来引进全局变量，则是在链接阶段发现错误。

7 全局变量可不可以定义在可被多个.C文件包含的头文件中？为什么？

可以。在不同的C文件中可以static的方式来声明，但是前提是只有一个C文件复制，否则会出现错误。

8 描述内存分配的方式以及区别

1 静态内存分配，内存在分配的时候就已经分配好了，在整个运行程序运行的期间都存在，如static变量和全局变量。

2 在栈上分配，执行函数的时候会在栈上分配局部变量，当函数执行结束的时候，局部变量就会被释放。

3 在堆上分配，这一部分可以由程序员决定，可以用malloc，new来分配内存，但是又要使用free和delete来处理释放。

9 类成员函数的重载，覆盖和隐藏的区别

1 重载：参数的个数，类型不同；

2 是指派生类覆盖父类的函数：不同的范围，基函数必须有virtual，函数名和函数参数都要相同；

3 隐藏是指派生类的函数隐藏了与其同名的基类的函数：如果派生类的函数与基类的函数同名，但是参数不同，无论是否有virtual，基类的函数将被隐藏；

如果派生类的函数与基类的函数同名，参数相同，但是没有virtual，基类的函数将被隐藏。

10 static的作用

1.设定作用域；

2设置存储形式。

11 说出const和\#define的区别

const常量有数据类型的，但是宏常量是没有数据类型的。编译器可以对前者进行类型检查，但是对后者只是字符串替换，可能会出想不到的错误。

12 简述一下数组和指针的区别？

1数组要么在静态存储区域分配内存，要么在栈上分配内存。但是指针可以指向任意的内存块

(1)修改内容上的差别

char a\[\] = “hello”;

a\[0\] = ‘X’;

char \*p = “world”; // 注意p 指向常量字符串

p\[0\] = ‘X’; // 编译器不能发现该错误，运行时错误  
(2) 用运算符sizeof 可以计算出数组的容量（字节数）。sizeof(p),p 为指针得到的是一个指针变量的字节数，而不是p 所指的内存容量。C++/C 语言没有办法知道指针所指的内存容量，除非在申请内存时记住它。注意当数组作为函数的参数进行传递时，该数组自动退化为同类型的指针。

13 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

14 变量在内存中存放的区域

全局变量                        全局静态区

全局静态变量                 全局静态区

全局常量

有初始化                       代码区

无初始化                       全局静态区

局部变量                       堆栈区

局部静态变量                静态区

局部常量                       堆栈区    v  
  new和malloc分配空间   堆区  
14 进程间的通信方式

管道，共享内存，信号量，socket，消息队列

15 线程同步方式

临界区：线程串行化访问的一段共享区域；

互斥：当一个线程访问共享资源的时候，其他的进程不能进入临界区；

信号量：用来控制互斥的一组变量。

16 进程和线程的区别

资源：进程是拥有资源的单位，但是线程没有用友资源；

调度：线程是调度和分配的基本单位，进程是资源的基本单位；

并行：进程间可以并行运行，线程是在进程内并行运行；

系统开销：进程创建和销毁是由系统决定的，进程创建的开销大，一个进程可以有多个线程。

17 纯虚函数和虚函数的区别

虚函数必须有实现，纯虚函数没有实现

虚函数可以不在派生类中重载，但是纯虚函数必须在每一个子类中去实现；

动态内存分配的时候，析构函数必须是虚函数，但没有必要是纯虚函数

18 面向对象的四大特性

继承：子类从父类中获得的属性和方法；

封装：把客观事物封装成抽象的类，让信任的类或者对象可以访问，不信任的则对信息隐藏引来。

多态：具有不同的数据类型表现出不同的行为。由继承产生的相关的不同的类，其对象对同一消息会做出不同的反应。

抽象：抽取共同的，本质的。

19 判断一个链表是否有环？

两个指针指向头指针，一个指针每次走一步，另一个指针每次走两步，如果有一个指针先为NULL,则没环；如果重复，则有环。

20 刷新缓冲区的方式？

print("/n")：换行刷新缓冲区。

fflush(stdout):函数刷新缓冲区。

return 0: 结束刷新缓冲区。

21 类和对象的概念

对象就是对客观事物在计算机上的描述；

类就是对有相似属性和行为的一组对象的描述。

22 数据库范式？

第一范式：没有重复的列；

第二范式：非主属的部分依赖于主属的部分；

第三范式：属性不依赖于其他非主属 的部分

23 ASSERT

调试程序中的一个宏，不满足，报告错误，并终止执行；

24 如果只想让程序有一个实例运行，不能运行两个。像winamp一样，只能开一个窗口，怎样实现

内存映射或全局原子（互斥变量），查找句柄，修改注册表，共享内存；

25如何截取键盘的响应，让所有的’a’变成’b’？

键盘钩子SetWindowsHookEx

char \*strcat(char \*strDes, const char \*strSrc)

assert((strDes != NULL) && (strSrc != NULL));

char \*address = strDes;

while (\*strDes != ‘\\0′)

++ strDes;

while ((\*strDes ++ = \*strSrc ++) != ‘\\0′)

NULL;

return address;

### strncat    ###

char \*strncat(char \*strDes, const char \*strSrc, int count)

assert((strDes != NULL) && (strSrc != NULL));

char \*address = strDes;

while (\*strDes != ‘\\0′)

++ strDes;

while (count — && \*strSrc != ‘\\0′ )

\*strDes ++ = \*strSrc ++;

\*strDes = ‘\\0′;

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, int count)

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 ++) != ‘\\0′)

NULL;

return address;

### strncpy    ###

char \*strncpy(char \*strDes, const char \*strSrc, int count)

assert(strDes != NULL && strSrc != NULL);

char \*address = strDes;

while (count — && \*strSrc != ‘\\0′)

\*strDes ++ = \*strSrc ++;

return address;

### strlen    ###

int strlen(const char \*str)

assert(str != NULL);

int len = 0;

while (\*str ++ != ‘\\0′)

++ len;

return len;

### strpbrk    ###

char \*strpbrk(const char \*strSrc, const char \*str)

assert((strSrc != NULL) && (str != NULL));

const char \*s;

while (\*strSrc != ‘\\0′)

s = str;

while (\*s != ‘\\0′)

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 != ‘\\0′; ++ strSrc)

for (s = strSrc, t = str; \*t != ‘\\0′ && \*s == \*t; ++s, ++t)

NULL;

if (\*t == ‘\\0′)

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 != ‘\\0′)

s = str;

while (\*s != ‘\\0′)

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 != ‘\\0′)

s = str;

while (\*s != ‘\\0′)

if (\*t == \*s)

break;

++ s;

if (\*s == ‘\\0′)

return t – strSrc;

++ t;

return 0;

### strrchr    ###

char \*strrchr(const char \*str, int c)

assert(str != NULL);

const char \*s = str;

while (\*s != ‘\\0′)

++ 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 != ‘\\0′)

++ 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 != ‘\\0′ && s – str < count; ++ s)

\*s = (char) c;

return str;

### strset    ###

char \*strset(char \*str, int c)

assert(str != NULL);

char \*s = str;

for (; \*s != ‘\\0′; ++ 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 != ‘\\0′)

t = str;

while (\*t != ‘\\0′)

if (\*s == \*t)

\*(strToken + (s – strToken)) = ‘\\0′;

return strToken;

++ t;

++ s;

return NULL;

### strupr    ###

char \*strupr(char \*str)

assert(str != NULL);

char \*s = str;

while (\*s != ‘\\0′)

if (\*s >= ‘a’ && \*s <= ‘z’)

\*s -= 0×20;

s ++;

return str;

### strlwr    ###

char \*strlwr(char \*str)

assert(str != NULL);

char \*s = str;

while (\*s != ‘\\0′)

if (\*s >= ‘A’ && \*s <= ‘Z’)

\*s += 0×20;

s ++;

return str;

### memcpy    ###

void \*memcpy(void \*dest, const void \*src, int count)

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, int c, 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, int count)

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, int count)

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 ++ != ‘\\0′)

++ len;

char \*strDes = (char \*) malloc (len + 1);

while ((\*strDes ++ = \*strSrc ++) != ‘\\0′)

NULL;

return strDes;

### strchr\_    ###

char \*strchr\_(char \*str, int c)

assert(str != NULL);

while ((\*str != (char) c) && (\*str != ‘\\0′))

str ++;

if (\*str != ‘\\0′)

return str;

return NULL;

### strchr    ###

char \*strchr(const char \*str, int c)

assert(str != NULL);

for (; \*str != (char) c; ++ str)

if (\*str == ‘\\0′)

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 int radix)

char \*bufptr;

char \*firstdig;

char temp;

unsigned int digval;

assert(buf != NULL);

bufptr = buf;

if (val < 0)

\*bufptr++ = ‘-’; val = (unsigned int)(-(int)val);

firstdig = bufptr;

digval =(unsigned int) val % radix;    val /= radix;

if (digval > 9)

\*bufptr++ = (char)(digval – 10 + ‘a’);

else

\*bufptr++ = (char)(digval + ’0′);

\} while(val > 0);

\*bufptr– = ‘\\0′;//设置字符串末尾，并将指针指向最后一个字符

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 = ‘\\0′;            //赋一个’\\0′

\}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 = new char\[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,int high)

/\*在下届为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()

char str\[\]=”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\\n”,str);

return 0;

方法二

\#include <stdio.h>

int main()\{

char\* src = “hello,world”;

int len = strlen(src);

char\* dest = (char\*)malloc(len+1);//要为\\0分配一个空间

char\* d = dest;

char\* s = &src\[len-1\];//指向最后一个字符

while( len– != 0 )

\*d++=\*s–;

\*d = 0;//尾部要加\\0

printf(“%s\\n”,dest);

free(dest);// 使用完，应当释放空间，以免造成内存汇泄露

return 0;

## 排序    ##

### 冒泡排序    ###

void bubble\_sort(int a\[\],int n)

int i,j;

for(i=0;i<n-1;i++)

bool x=ture;

for(j=0;j<n-1-i;j++)

int temp;

if(a\[j\]>a\[j+1\])

temp=a\[j\];

a\[j\]=a\[j+1\];

a\[j+1\]=temp;

x=false;

if(x) break;

时间复杂度O(N^2)

### 选择排序    ###

void select\_sort(int a\[\],int n)

int i,j;

for(i=0;i<n-1;i++)

int min=i;

for(j=i+1;j<n;j++)

if(a\[j\]<a\[min\])

min=j;

if(min!=i)

int temp=a\[j\];

a\[j\]=a\[min\];

a\[min\]=temp;

时间复杂度O(N^2)

### 插入排序    ###

void insert\_sort(int a\[\],int n)

int i,j;

for(i=1;i<n;i++)

int x=a\[i\];

for(j=i;j>0&&x<a\[j-1\];j–)

a\[j\]=a\[j-1\];

a\[j\]=x;

时间复杂度O(N^2)

### 快速排序    ###

void quick\_sort(int a\[\],int ileft,int iright)

int iPivot=(left+right)/2;

int nPivot=a\[iPivot\];

for(int i=ileft,j=iright;i<j;)

while(!(i>=iPivot||nPivot<a\[i\]))

i++;

if(i<iPivot)

a\[iPivot\]=a\[i\];

iPivot=i;

while(!(j<=iPivot||nPivot>a\[j\]))

j–;

if(j>iPivot)

a\[iPivot\]=a\[j\];

iPivot=j;

a\[iPivot\]=nPivot;

if(iPivot-ileft>1)

quick\_sort(a,ileft,iPivot-1);

if(iright-iPivot>1)

quick\_sort(a,iPivot+1,iright);

时间复杂度O(NlogN)

## 链表    ##

### 单链表    ###

### 双链表    ###

### 循环链表    ###

### 单链表逆置    ###

void reverse(link \*head)

link \*p, \*s, \*t;

p = head;

s = p->next;

while(s->next!=NULL)

t = s->next;

s->next = p;

p = s;

s = t;

s->next = p;

head->next->next = NULL;    //尾指针置为空

head->next = s;         //赋值到头指针后一位

### 链表合并    ###

Node \* Merge(Node \*head1 , Node \*head2)

if ( head1 == NULL)

return head2 ;

if ( head2 == NULL)

return head1 ;

Node \*head = NULL ;

Node \*p1 = NULL;

Node \*p2 = NULL;

if ( head1->data < head2->data )

head = head1 ;

p1 = head1->next;

p2 = head2 ;

\}else

head = head2 ;

p2 = head2->next ;

p1 = head1 ;

Node \*pcurrent = head ;

while ( p1 != NULL && p2 != NULL)

if ( p1->data <= p2->data )

pcurrent->next = p1 ;

pcurrent = p1 ;

p1 = p1->next ;

\}else

pcurrent->next = p2 ;

pcurrent = p2 ;

p2 = p2->next ;

if ( p1 != NULL )

pcurrent->next = p1 ;

if ( p2 != NULL )

pcurrent->next = p2 ;

return head ;

递归方式：

Node \* MergeRecursive(Node \*head1 , Node \*head2)

if ( head1 == NULL )

return head2 ;

if ( head2 == NULL)

return head1 ;

Node \*head = NULL ;

if ( head1->data < head2->data )

head = head1 ;

head->next = MergeRecursive(head1->next,head2);

else

head = head2 ;

head->next = MergeRecursive(head1,head2->next);

return head ;

## 写一个Singleton模式    ##

\#include<iostream>

using namespace std;

class Singleton

private:

static Singleton\* \_instance;

protected:

Singleton()

cout<<”Singleton”<<endl;

public:

static Singleton\* Instance()

if(NULL==\_instance)

\_instance=new Singleton();

return \_instance;

\};

static Singleton\* Singleton::\_instance=NULL;

int main()

Singleton \* s =Singleton::Instance();

Singleton \* s1=Singleton::Instance();

## 如何对String类型数据的某个字符进行访问？    ##

\#include<iostream>

using namespace std;

int main()

string s=”abcdefg”;

const char \*c=s.c\_str();

while(\*c!=’\\0′)

printf(“%c”,\*c++);

## 文件加密、解密    ##

### 1.加密（encryption）：    ###

\#include<stdio.h>

void  encryption(char \*ch)

(\*ch)^=0xFF; //算法可自行修改调整，使用AES加密算法

int main(int argc,char \*argv\[\])

if(argc<2)

printf(“参数不足”);

return -1;

//文件的打开（fopen函数）

/\*

r    read    只读

w    write    只写

a    append    追加

t    text    文本文件，可省略不写

b    banary    二进制文件

+    读和写

\*/

a.out      a.c       b.txt

argv\[0\]    argv\[1\]   argv\[2\]

FILE\* fpr=NULL;

FILE\* fpw=NULL;

//文件打开失败返回一个空指针值NULL

if(NULL==(fpr=fopen(argv\[1\],”r”)))\{printf(“%m\\n”);return -1;\}

if(NULL==(fpw=fopen(argv\[2\],”w+”)))\{printf(“%m\\n”);return -1;\}

char ch;

while((ch=fgetc(fpr))!=EOF)

//putchar(ch);

encryption(&ch);//加密函数

printf(“%c”,ch);//加密后字符显示

fputc(ch,fpw);//存放进文件

printf(“\\n文件加密成功！\\n”);

//文件的关闭(fclose函数)

fclose(fpr);

fclose(fpw);

### 2.解密（decryption）：    ###

\#include<stdio.h>

\#include<time.h>

void show()

time\_t start=time(NULL);

while(start==time(NULL));

void decryption(char ch)

(\*ch)^=0xFF;//算法可自行修改调整

int main(int argc,char \*argv\[\])

if(argc<2)

printf(“参数不足”);

return -1;

//文件的打开（fopen函数）

/\*

r    read    只读

w    write    只写

a    append    追加

t    text    文本文件，可省略不写

b    banary    二进制文件

+    读和写

\*/

FILE\* fpr=NULL;

FILE\* fpw=NULL;

//文件打开失败返回一个空指针值NULL

if(NULL==(fpr=fopen(argv\[1\],”r”)))\{printf(“%m\\n”);return -1;\}

if(NULL==(fpw=fopen(argv\[2\],”w+”)))\{printf(“%m\\n”);return -1;\}

char ch;

printf(“开始解密！\\n”);

while((ch=fgetc(fpr))!=EOF)

show();

ch=decryption(ch);//解密函数

printf(“%c”,ch);//解密后字符显示

fputc(ch,fpw);//存放进文件

fflush(stdout);//刷新显示

printf(“\\n文件解密成功！\\n”);

//文件的关闭(fclose函数)

fclose(fpr);

fclose(fpw);

## 斐波那契数列（Fibonacci sequence）    ##

int  Funct( int n )

if( n==0 || n==1 ) return 1;

retrurn  Funct(n-1) + Funct(n-2);

C++基础知识点

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 Java基础知识（知识点）

相关 java基础知识点_java基础知识点总结归纳

相关 C++模块1：基础知识点梳理

相关 java基础扩展知识点_Java基础知识点

相关 C++基础知识点

相关 C/C++基础知识点总结

相关 C++知识点

相关 C语言基础知识点总结

相关 C++知识点

相关 html基础知识点