计算机C语言的知识点是什么

继承

多态

封装

虚函数

。。。。。。

一、#include “filenameh”和#include <filenameh>的区别

#include “filenameh”是指编译器将从当前工作目录上开始查找此文件

#include <filenameh>是指编译器将从标准库目录中开始查找此文件

二、头文件的作用

加强安全检测

通过头文件可能方便地调用库功能，而不必关心其实现方式

三、 , &修饰符的位置

对于和&修饰符，为了避免误解，最好将修饰符紧靠变量名

四、if语句

不要将布尔变量与任何值进行比较，那会很轻易出错的。

整形变量必须要有类型相同的值进行比较

浮点变量最好少比点，就算要比也要有值进行限制

指针变量要和NULL进行比较，不要和布尔型和整形比较

五、const和#define的比较

const有数据类型，#define没有数据类型

个别编译器中const可以进行调试，#define不可以进行调试

在类中定义常量有两种方式

1、 在类在声明常量，但不赋值，在构造函数初始化表中进行赋值；

2、 用枚举代替const常量。

六、C++函数中值的传递方式

有三种方式：值传递(Pass by value)、指针传递(Pass by pointer)、引用传递(Pass by reference)

void fun(char c) //pass by value

void fun(char str) //pass by pointer

void fun(char &str) //pass by reference

假如输入参数是以值传递的话，最好使用引用传递代替，因为引用传递省去了临时对象的构造和析构

函数的类型不能省略，就算没有也要加个void

七、函数体中的指针或引用常量不能被返回

Char func(void)

{

char str[]=”Hello Word”;

//这个是不能被返回的，因为str是个指定变量，不是一般的值，函数结束后会被注销掉

return str;

}

函数体内的指针变量并不会随着函数的消亡而自动释放

八、一个内存拷贝函数的实现体

void memcpy(void pvTo,const void pvFrom,size_t size)

{

assert((pvTo!=NULL)&&(pvFrom!=NULL));

byte pBTo=(byte)pvTo; //防止地址被改变

byte pbFrom=(byte)pvFrom;

while (size-- >0)

pbTo++ = pbForm++;

return pvTo;

}

九、内存的分配方式

分配方式有三种，请记住，说不定那天去面试的时候就会有人问你这问题

1、 静态存储区，是在程序编译时就已经分配好的，在整个运行期间都存在，如全局变量、常量。

2、 栈上分配，函数内的局部变量就是从这分配的，但分配的内存轻易有限。

3、 堆上分配，也称动态分配，如我们用new,malloc分配内存，用delete,free来释放的内存。

十、内存分配的注重事项

用new或malloc分配内存时，必须要对此指针赋初值。

用delete 或free释放内存后，必须要将指针指向NULL

不能修改指向常量的指针数据

十一、内容复制与比较

//数组……

char a[]=”Hello Word!”;

char b[10];

strcpy(b,a);

if (strcmp(a,b)==0)

{}

//指针……

char a[]=”Hello Word!”;

char p;

p=new char[strlen(a)+1];

strcpy(p,a);

if (strcmp(p,a)==0)

{}

十二、sizeof的问题

记住一点，C++无法知道指针所指对象的大小，指针的大小永远为4字节

char a[]=”Hello World!”

char p=a;

count<<sizeof(a)<<end; //12字节

count<<sizeof(p)<<endl; //4字节

而且，在函数中，数组参数退化为指针，所以下面的内容永远输出为4

void fun(char a[1000])

{

count<<sizeof(a)<<endl; //输出4而不是1000

}

十三、关于指针

1、 指针创建时必须被初始化

2、 指针在free 或delete后必须置为NULL

3、 指针的长度都为4字节

4、释放内存时，假如是数组指针，必须要释放掉所有的内存，如

char p=new char[100];

strcpy(p,”Hello World”);

delete []p; //注重前面的〔〕号

p=NULL;

5、数组指针的内容不能超过数组指针的最大轻易。

如:

char p=new char[5];

strcpy(p,”Hello World”); //报错 目标轻易不够大

delete []p; //注重前面的〔〕号

p=NULL;

十四、关于malloc/free 和new /delete

l malloc/free 是C/C+的内存分配符，new /delete是C++的内存分配符。

l 注重：malloc/free是库函数，new/delete是运算符

l malloc/free不能执行构造函数与析构函数，而new/delete可以

l new/delete不能在C上运行，所以malloc/free不能被淘汰

l 两者都必须要成对使用

l C++中可以使用_set_new_hander函数来定义内存分配异常的处理

十五、C++的特性

C++新增加有重载(overload)，内联（inline），Const，Virtual四种机制

重载和内联：即可用于全局函数，也可用于类的成员函数；

Const和Virtual：只可用于类的成员函数；

重载：在同一类中，函数名相同的函数。由不同的参数决定调用那个函数。函数可要不可要Virtual要害字。和全局函数同名的函数不叫重载。假如在类中调用同名的全局函数，必须用全局引用符号::引用。

覆盖是指派生类函数覆盖基类函数

函数名相同；

参数相同；

基类函数必须有Virtual要害字；

不同的范围(派生类和基类)。

隐藏是指派生类屏蔽了基类的同名函数相同

1、 函数名相同，但参数不同，此时不论基类有无Virtual要害字，基类函数将被隐藏。

2、 函数名相同，参数也相同，但基类无Virtual要害字(有就是覆盖)，基类函数将被隐藏。

内联：inline要害字必须与定义体放在一起，而不是单单放在声明中。

Const：const是constant的缩写，“恒定不变”的意思。被const修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。

1、 参数做输入用的指针型参数，加上const可防止被意外改动。

2、 按值引用的用户类型做输入参数时，最好将按值传递的改为引用传递，并加上const要害字，目的是为了提高效率。数据类型为内部类型的就没必要做这件事情；如：

将void Func(A a) 改为void Func(const A &a)。

而void func(int a)就没必要改成void func(const int &a);

3、 给返回值为指针类型的函数加上const，会使函数返回值不能被修改，赋给的变量也只能是const型变量。如：函数const charGetString(void); char str=GetString()将会出错。而const char str=GetString()将是正确的。

4、 Const成员函数是指此函数体内只能调用Const成员变量，提高程序的键壮性。如声明函数 int GetCount(void) const;此函数体内就只能调用Const成员变量。

Virtual：虚函数：派生类可以覆盖掉的函数，纯虚函数：只是个空函数，没有函数实现体；

十六、extern“C”有什么作用？

Extern “C”是由C＋＋提供的一个连接交换指定符号，用于告诉C＋＋这段代码是C函数。这是因为C++编译后库中函数名会变得很长，与C生成的不一致，造成C＋＋不能直接调用C函数，加上extren “c”后，C++就能直接调用C函数了。

Extern “C”主要使用正规DLL函数的引用和导出 和 在C++包含C函数或C头文件时使用。使用时在前面加上extern “c” 要害字即可。

十七、构造函数与析构函数

派生类的构造函数应在初始化表里调用基类的构造函数；

派生类和基类的析构函数应加Virtual要害字。

不要小看构造函数和析构函数，其实编起来还是不轻易。

#include <iostreamh>

class Base

{

public:

virtual ~Base() { cout<< "~Base" << endl ; }

};

class Derived : public Base

{

public:

virtual ~Derived() { cout<< "~Derived" << endl ; }

};

void main(void)

{

Base pB = new Derived; // upcast

delete pB;

}

输出结果为：

~Derived

~Base

假如析构函数不为虚，那么输出结果为

~Base

太多了，先写这些

new也分配到堆上，栈上分自动变量（就是局部变量）

区别

1、new 是c++中的 *** 作符，malloc是c 中的一个函数

2、new 不止是分配内存，而且会调用类的构造函数，同理delete会调用类的析构函数，而malloc则只分配内存，不会进行初始化类成员的工作，同样free也不会调用析构函数

3、内存泄漏对于malloc或者new都可以检查出来的，区别在于new可以指明是那个文件的那一行，而malloc没有这些信息。

4、new 和 malloc效率比较

new 有三个字母, malloc有六个字母

new可以认为是malloc加构造函数的执行。

new出来的指针是直接带类型信息的。

而malloc返回的都是void指针。

一：new delete 是运算符，malloc,free是函数

malloc与free是C++/C语言的标准库函数，new/delete是C++的运算符。它们都可用于申请动态内存和释放内存。

对于非内部数据类型的对象而言，光用maloc/free无法满足动态对象的要求。对象在创建的同时要自动执行构造函数，对象在消亡之前要自动执行析构函数。由于malloc/free是库函数而不是运算符，不在编译器控制权限之内，不能够把执行构造函数和析构函数的任务强加于malloc/free。

因此C++语言需要一个能完成动态内存分配和初始化工作的运算符new，以及一个能完成清理与释放内存工作的运算符delete。注意new/delete不是库函数。

一、删除内容不同

1、delete：只删除数据不删除表的结构。

2、drop：句将删除表的结构被依赖的约束(constrain)、触发器(trigger)、索引(index)。

二、语句效果不同

1、delete：是数据库 *** 作语言(dml)，这个 *** 作会放到 rollback segement 中，事务提交之后才生效；如果有相应的 trigger，执行的时候将被触发。

2、drop：是数据库定义语言(ddl)， *** 作立即生效，原数据不放到 rollback segment 中，不能回滚， *** 作不触发 trigger。

三、删除空间影响不同

1、delete：不影响表所占用的 extent，高水线(high watermark)保持原位置不动。

2、drop：语句将表所占用的空间全部释放。

-SQL语句大全

-sql语句

c++

用的是

delete吧

我觉得系统会自动调用释放内存的函数的

应该不用自己加的

无论返回什麽结构

在内存调用完的每个函数的入口地址都是指向函数的指针阿

就像你的例子

tm

指向

localtime()入口地址

如果系统没有自动释放的话

后果将不堪设想喔

想想全局变量带来的危机

其实道理差不多

所以不用free了吧

我猜的

哈哈

void delete_student(student L,long studentnum)

{

int flag = 0;

student p = L,q = p->next;

while(q)

{

if(q->number == studentnum)

{

flag = 1;

q = q->next;

break;

}

else

{

p = q;

q = q->next; /下一个结点/

}

}

if(flag == 0)

printf("删除学生失败，不存在这个学号的学生\n");

else{

printf("删除学生成功! \n ");

}

}

某个文件中定义的静态全局变量(或称静态局部变量)作用域是------本文件内

①：默认继承权限：

class的继承按照private继承处理，struct的继承按照public继承处理

②：成员的默认访问权限

class的成员默认是private权限， struct默认是public权限

注：C++有内置的宏__cplusplus -------有个习惯带“__”表示内部变量，只供内部使用；不带双下划线的，表示外部接口的变量（标识符）

C++函数的三种传递方式为：值传递。指针传递 和 引用传递

注：值传递和指针传递，本质上就是指针传递。

在A类中fun1是虚函数；B类中fun2是虚函数。

①：机制上：c是面向过程的（c也可以是面向对象发的程序)； C++是面向对象，提供了类。C++的面向对象的程序比c容易。

②：使用方向：c适合代码体积小的，效率高的场合，如嵌入式；C++更适合上层的，复杂的；Linux核心大部分是c写的，因为他是系统软件，效率要求极高

③：C++是c的超集；

④：C语言是结构化编程语言，C++是面向对象编程语言。

⑤：C++侧重于对象而不是过程，侧重于类的设计而不是逻辑设计。

C中struct主要提供的是自定义类型，和构造一种新的类型出来；

一致的地方：

不一致的地方：

C语言： 无Protection行为； 不能定义函数，但可以有函数指针；

C++： 有Procetion行为，默认是private； 可以定义函数。

注： 就是访问权限，struct对于外部是完全访问的，C++是有访问 权限 设置的；

正确， sizeof 是编译时运算符，编译时就确定了 可以看成是和及其有关的常量

注：定义数组的时候，数组的长度必须是一个确定的常量；

形参：是在定义函数时指定的参数，在未调用时他们并不占用内存中的存储单元。只有在调用的时候才会被分配内存，调用结束后，形参所占用的内存单元会被释放

实参：即你调用函数时传递的参数；

重载： 同一个名字空间--- -函数名相同，参数列表不同 ； 注释：理解成一个类里面的多个同名函数

重写/覆盖： 不同名字空间-----用于继承，子类重新定义父类中 函数名相同，参数列表也相同 虚函数 的方法

重定义/隐藏：重定义(隐藏)是指派生类的函数屏蔽了与其同名的基类函数，规则如下：

a 如果派生类的函数和基类的 函数同名，但是参数不同 ，此时，不管有无virtual，基类的函数被隐藏。

b 如果派生类的函数与基类 的函数同名，并且参数也相同 ，但是基类函数没有vitual关键字，此时，基类的函数被隐藏。

①： 隐藏 实现 细节 ，使得代码能够模块化；扩展代码模块， 实现代码重写

②： 接口重用 ：为了使用多个派生类中某个派生类的属性正确调用

用sizeof的方法：

定义一个指针P，打印出sizeof（P），如果结果是4，怎么标识改 *** 作系统是32位，如果打印结果是2，则标识是16位、。

虚函数 表 ，是在 编译 期就建立了。各个虚函数被组织成一个虚函数的入口地址的数组（简而言之，就是组成了一个存放虚函数地址的数组）

虚函数表 指针 是在 运行 时建立的，也就是构造函数被调用时进行初始化的。

封装，继承，多态 是什么？怎那么用？为什么使用它？

封装：将客观事物抽象成类，每个类对自身的 数据 和 方法 实行 protection ; 注释 : 保护内部成员

继承：广义的继承有三种实现形式：

实现继承：指使用基类的属性和方法，而无需额外编码的能力；

可视继承：子窗体使用父窗体的外观和实现代码

接口继承：仅使用属性和方法，实现之后到子类实现

前两种和后一种构成了功能复用的两种方法

多态： 主要是为了抽象

只要是函数都会做类型检查。

这是内联函数跟宏观比的优势。

①：静态存储区域分配； 内存在编译的时候就已经分配好了，这块内存在程序的整个运行期间都存在。例如全局变量。

②：在展区创建；在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时，自动被释放。效率高，但是内存容量有限。

③：从堆上分配：或者叫：动态内存分配。程序员自己负责在何时用free或delete释放内存。

C语言中用带参数的宏定义，C++中用inline

生命周期不同 空间 周期

局部变量 函数调用时创建，结束时销毁。static除外

局部变量不具有外部链接，全局变量

全局变量 ： 静态数据区

局部变量： 放在栈区

malloc、free是C++/C语言标准库，new、delete是C++运算符。

注意：new、delete不是库函数；

malloc/free 无法 满足 对象在创建的时候要自动 执行 构造函 数，对象消亡之前要自动执行 析构函数 。他们是库函数，而不是运算符，不在编译器的控制权限内，。

new、delete 能完成内存的分配和释放，已经初始化和清理工作。

判断指针是否为空，如果空，则打印错误log，并且return，终止本函数。

不是，两个不同类型的指针可以强制转换。

动态申请；

知道运行时才知道一个对象需要多少存储空间，不需要知道对象的生存周期有多长。

Debug调试版本，它包含调试信息，比如assert的适用，并且不作任何优化，便于程序员调试程序。

Release称为发布版本，他往往时进行了各种优化，

析构函数时特殊的类成员函数，没有返回类型，没有参数，不能随意调用，也没有重载，只有在类对象的生命周期结束时，有系统自己调用。优势方内存空间的作用。

虚函数是C++多态的一种表现，使用虚函数，我们可以灵活的进行动态绑定，当然是以一定的开销为代价

（这里虚函数的适用还是不太懂，需要进一步学习，比如怎么调用子类的一切啊）

导致文件描述符结构中指针指向的内存背重复释放，进而导致一些不可预期的异常。

比如全局变量的初始化，就不是有main函数引起的。例如：

全局对象的构造函数，会在main函数之前执行。

多态，纯虚函数，抽象类

内联函数

虚函数的特点：如果希望派生类能够重新定义基类的方法，则在基类中将该方法定义为虚方法，这样可以启用动态联编。

内联函数的特点：使用内联函数的目的屎我了提高函数的运行侠侣。内联函数的代码不能过长，因为内联函数省去调用函数的时间是以代码膨胀为代价的。内联函数不能包含循环语句。因为执行循环语句要比调用函数的开销大。

函数模板的实例化是由编译程序在处理函数嗲用时自动完成的，

类模板的实例化必须由程序员在程序中显示的指定

函数名和参数列表

不能被重载的运算符：

①：不能改变C++内部数据类型（如int float 等）的运算符

②：不能重载“”，因为在类中对任何成员都有意义，已经成为标准用法

③：不能重载目前C++运算符集合中没有的符号，如：@， 等。愿意：一是难以理解，二是无法确定优先级

④：对已经存在的运算符重载不能改变优先级规则，否则将引起混乱。

有可能是派生类无法调用析构函数

模板可以说比较古老了，但是当前的泛型编程实质上就是模板编程。他体现了一种通用和泛化的思想。

STL有7中容器：

vector（零食进行存储数据的访问），list（经常进行数据的增删改查），deque（队列结构），map,multimap,set（构造栈形的数据使用）,multiset

容器是一种特定用途的类；

浅拷贝 知识拷贝了指针没有拷贝资源

深拷贝进行了资源的拷贝

三元表达式“？：”问好后面的两个 *** 作数必须为同一个类型。否则会出问题。

总的来说，堆是C语言和 *** 作系统的术语，是 *** 作系统维护的一块动态分配内存；自由存储是C++中通过 new与delete动态分配和释放对象的抽象概念。 他们并不是完全一样。

从技术上来说，堆（heap）是C语言和 *** 作系统的术语。堆是 *** 作系统所维护的一块特殊内存，它提供了动态分配的功能，当运行程序调用malloc()时就会从中分配，稍后调用free可把内存交还。而自由存储是C++中通过new和delete动态分配和释放对象的抽象概念，通过new来申请的内存区域可称为自由存储区。基本上，所有的C++编译器默认使用堆来实现自由存储，也即是缺省的全局运算符new和delete也许会按照malloc和free的方式来被实现，这时藉由new运算符分配的对象，说它在堆上也对，说它在自由存储区上也正确。

程序编译的过程中就是将用户的文本形式的源代码(c/c++)转化成计算机可以直接执行的机器代码的过程。主要经过四个过程：预处理、编译、汇编和链接。具体示例如下。

一个helloc的c语言程序如下。

其编译过程如下：

最简单的理解是new和delete是运算符，而malloc和free是函数。

由于malloc/free是库函数而不是运算符，不在编译器控制权限之内，不能够构把造函数和析构函数的任务强加于malloc/free；因此c++语言需要一个能完成内存分配和初始化工作的运算符new，以及一个能完成清理与释放内存工作的运算符delete。