C笔记

Define const

如果一个整形常量开头为0,会被视作八进制

双引号字符串表示指向无名数组起始的指针,数组被双引号之间的字符和’’初始化

“yes”被编译器识别为’y’,’e’,’s’,’’ 四个连续内存单元的首地址

‘ye’被编译器识别为一个整数值

a+++++b 被识别为((a++)++)+b 编译器从左往右识别,但是这个表达式会报错,因为第二个++左边不是一个变量

函数名分f(),如果写f的话,能够计算f的地址,但是不调用该函数

数组:

C数组为一维时,需要在编译器确定大小

int *ip;声明指针变量

ip=&i;指针指向i

*ip=17;i的值改为17

hello=”hello”

hello和&hello[0]相等

*hello和hello[0]相等

数组指针(也称行指针)

定义 int (*p)[n];

()优先级高,首先说明p是一个指针,指向一个整型的一维数组,这个一维数组的长度是n,也可以说是p的步长。也就是说执行p+1时,p要跨过n个整型数据的长度。

如要将二维数组赋给一指针,应这样赋值:

int a[3][4];

int (*p)[4]; //该语句是定义一个数组指针,指向含4个元素的一维数组。

 p=a; //将该二维数组的首地址赋给p,也就是a[0]或&a[0][0]

 p++; //该语句执行过后,也就是p=p+1;p跨过行a[0][]指向了行a[1][]

所以数组指针也称指向一维数组的指针,亦称行指针。

int a[5] = {1, 2, 3, 4, 5};

&a是行指针,a才是int指针 a+1是加了5个int地址

a, &a的地址是一样的,但是意思不一样

指针数组

定义 int *p[n];

[]优先级高,先与p结合成为一个数组,再由int*说明这是一个整型指针数组,它有n个指针类型的数组元素。这里执行p+1时,则p指向下一个数组元素,这样赋值是错误的:p=a;因为p是个不可知的表示,只存在p[0]、p[1]、p[2]...p[n-1],而且它们分别是指针变量可以用来存放变量地址。但可以这样 *p=a; 这里*p表示指针数组第一个元素的值,a的首地址的值。

如要将二维数组赋给一指针数组:

int *p[3];

int a[3][4];

p++; //该语句表示p数组指向下一个数组元素。注:此数组每一个元素都是一个指针

for(i=0;i<3;i++)

p[i]=a[i]

这里int *p[3] 表示一个一维数组内存放着三个指针变量,分别是p[0]、p[1]、p[2]

所以要分别赋值。

这样两者的区别就豁然开朗了,数组指针只是一个指针变量,似乎是C语言里专门用来指向二维数组的,它占有内存中一个指针的存储空间。指针数组是多个指针变量,以数组形式存在内存当中,占有多个指针的存储空间。

还需要说明的一点就是,同时用来指向二维数组时,其引用和用数组名引用都是一样的。

比如要表示数组中i行j列一个元素:

*(p[i]+j)、*(*(p+i)+j)、(*(p+i))[j]、p[i][j]

优先级:()>[]>*

char str1[] = "abc"; 

char str2[] = "abc"; 


const char str3[] = "abc"; 

const char str4[] = "abc"; 


const char* str5 = "abc"; 

const char* str6 = "abc"; 

str1和str2都是字符数组,每个都有其自己的存储区,它们的值则是各存储区首地址,不等;str3和str4同上,只是按const语义,它们所指向的数据区不能修改。str5和str6并非数组而是字符指针,并不分配存储区,其后的“abc”以常量形式存于静态数据区,而它们自己仅是指向该区首地址的指针,所以相等。

Strcpy

s=”sdsadasdas”

t=”sdasdsa”

拼接到r(需要r大小能够容纳s+t,且s和t内存区不能重叠)

r=malloc(strlen(s)+strlen(t))

strcpy(r,s)

strcat(r,t)

strncpy函数(需要加#include ):多个n代表可以指定字符个数进行赋值。原型:char * strncpy(char *dest, char *src, size_tn); 功能:将字符串src中最多n个字符复制到字符数组dest中(它并不像strcpy一样遇到NULL才停止复制,而是等凑够n个字符才开始复制),返回指向dest的指针。要求:如果n > dest串长度,dest栈空间溢出产生崩溃异常。该函数注意的地方和strcpy类似,但是n值需特别注意

strncpy(s1,s2,3);

scanf("%6.2f%d",&a,&b); 错在scanf()不允许指定精度

scanf("%f%3o",&a,&b);      %3o是接受3位八进制整数的意思,与&b匹配

sizeof(str)和strlen(str):sizeof比strlen多1,因为计算了’’

Sizeof与Strlen的区别与联系

1.sizeof操作符的结果类型是size_t,它在头文件中typedef为unsigned int类型。

该类型保证能容纳实现所建立的最大对象的字节大小。

2.sizeof是算符,strlen是函数。

3.sizeof可以用类型做参数,strlen只能用char*做参数,且必须是以''\0''结尾的。

sizeof还可以用函数做参数,比如:

short f();

printf("%d\n", sizeof(f()));

输出的结果是sizeof(short),即2。

4.数组做sizeof的参数不退化,传递给strlen就退化为指针了。

5.大部分编译程序 在编译的时候就把sizeof计算过了 是类型或是变量的长度这就是sizeof(x)可以用来定义数组维数的原因

char str[20]="0123456789";

int a=strlen(str); //a=10;

int b=sizeof(str); //而b=20;

6.strlen的结果要在运行的时候才能计算出来,时用来计算字符串的长度,不是类型占内存的大小。

7.sizeof后如果是类型必须加括弧,如果是变量名可以不加括弧。这是因为sizeof是个操作符不是个函数。

8.当适用了于一个结构类型时或变量, sizeof 返回实际的大小,

当适用一静态地空间数组, sizeof 归还全部数组的尺寸。

sizeof 操作符不能返回动态地被分派了的数组或外部的数组的尺寸

9.数组作为参数传给函数时传的是指针而不是数组,传递的是数组的首地址,

如:

fun(char [8])

fun(char [])

都等价于 fun(char *)

在C++里参数传递数组永远都是传递指向数组首元素的指针,编译器不知道数组的大小

如果想在函数内知道数组的大小, 需要这样做:

进入函数后用memcpy拷贝出来,长度由另一个形参传进去

fun(unsiged char *p1, int len)

{

 unsigned char* buf = new unsigned char[len+1]

 memcpy(buf, p1, len);

}

我们能常在用到 sizeof 和 strlen 的时候,通常是计算字符串数组的长度

看了上面的详细解释,发现两者的使用还是有区别的,从这个例子可以看得很清楚:

char str[20]="0123456789";

int a=strlen(str); //a=10; >>>> strlen 计算字符串的长度,以结束符 0x00 为字符串结束。

int b=sizeof(str); //而b=20; >>>> sizeof 计算的则是分配的数组 str[20] 所占的内存空间的大小,不受里面存储的内容改变。 

上面是对静态数组处理的结果,如果是对指针,结果就不一样了

char* ss = "0123456789";

sizeof(ss) 结果 4 ===》ss是指向字符串常量的字符指针,sizeof 获得的是一个指针的之所占的空间,应该是

长整型的,所以是4

sizeof(*ss) 结果 1 ===》*ss是第一个字符 其实就是获得了字符串的第一位'0' 所占的内存空间,是char类

型的,占了 1 位

strlen(ss)= 10 >>>> 如果要获得这个字符串的长度,则一定要使用 strlen

cin输入时遇到空格会结束,所以一般用getline作为字符串的输入(含空格)。

cin>>

该操作符是根据后面变量的类型读取数据。

输入结束条件 :遇到Enter、Space、Tab键。

对结束符的处理 :丢弃缓冲区中使得输入结束的结束符(Enter、Space、Tab)

拷贝构造函数 MyClass(const MyClass & x);

赋值运算符 MyClass operator= (const MyClass & x);

析构函数 ~MyClass();

using namespace std这句话其实就表示了所有的标准库函数都在标准命名空间std中进行了定义。其作用就在于避免发生重命名的问题。C++引入了命名空间namespace主要解决了多个程序员在编写同一个项目中可能出现的函数等重名的现象。解决方法就是加上自己的命名空间。

#include

using namespace std;

namespace ZhangSan

{

 int a=10; //张三把10赋值给了变量a

}

namespace LiSi

{

 int a=5; //李四把10赋值给了变量a

}


void main()

{

 int a=1;

 cout<<"张三定义的a="<

 cout<<"李四定义的a="<

 cout<<"主函数定义的a="<

}

vector(向量): C++中的一种数据结构,确切的说是一个类.它相当于一个动态的数组,当程序员无法知道自己需要的数组的规模多大时,用其来解决问题可以达到最大节约空间的目的.

 用法:

 1.文件包含:    

   首先在程序开头处加上#include以包含所需要的类文件vector

  还有一定要加上using namespace std;

  2.变量声明:

  2.1 例:声明一个int向量以替代一维的数组:vector a;(等于声明了一个int数组a[],大小没有指定,可以动态的向里面添加删除)。

  2.2 例:用vector代替二维数组.其实只要声明一个一维数组向量即可,而一个数组的名字其实代表的是它的首地址,所以只要声明一个地址的向量即可,即:vector a.同理想用向量代替三维数组也是一样,vector a;再往上面依此类推.

 3.具体的用法以及函数调用:

 3.1 如何得到向量中的元素?其用法和数组一样:

 例如:

 vector a

 int b = 5;

 a.push_back(b);//该函数下面有详解

 cout<

1.push_back 在数组的最后添加一个数据

2.pop_back 去掉数组的最后一个数据

3.at 得到编号位置的数据

4.begin 得到数组头的指针

5.end 得到数组的最后一个单元+1的指针

6.front 得到数组头的引用

7.back 得到数组的最后一个单元的引用

8.max_size 得到vector最大可以是多大

9.capacity 当前vector分配的大小

10.size 当前使用数据的大小

11.resize 改变当前使用数据的大小,如果它比当前使用的大,者填充默认值

12.reserve 改变当前vecotr所分配空间的大小

13.erase 删除指针指向的数据项

14.clear 清空当前的vector

15.rbegin 将vector反转后的开始指针返回(其实就是原来的end-1)

16.rend 将vector反转构的结束指针返回(其实就是原来的begin-1)

17.empty 判断vector是否为空

18.swap 与另一个vector交换数据

3.2 详细的函数实现功能:其中vector c.

 c.clear() 移除容器中所有数据。

 c.empty() 判断容器是否为空。

   c.erase(pos) 删除pos位置的数据

 c.erase(beg,end) 删除[beg,end)区间的数据

 c.front() 传回第一个数据。

 c.insert(pos,elem) 在pos位置插入一个elem拷贝

 c.pop_back() 删除最后一个数据。

          c.push_back(elem) 在尾部加入一个数据。

 c.resize(num) 重新设置该容器的大小

 c.size() 回容器中实际数据的个数。

 c.begin() 返回指向容器第一个元素的迭代器

 c.end() 返回指向容器最后一个元素的迭代器

const常量与define宏定义的区别

#define RADIUS 100;

const float RADIUS = 100;

(1) 编译器处理方式不同

  define宏是在预处理阶段展开。

  const常量是编译运行阶段使用。

(2) 类型和安全检查不同

  define宏没有类型,不做任何类型检查,仅仅是展开。

  const常量有具体的类型,在编译阶段会执行类型检查。

(3) 存储方式不同

  define宏仅仅是展开,有多少地方使用,就展开多少次,不会分配内存。(宏定义不分配内存,变量定义分配内存。)

  const常量会在内存中分配(可以是堆中也可以是栈中)。

(4)const 可以节省空间,避免不必要的内存分配。 例如: 

 #define PI 3.14159 //常量宏 

 const doulbe Pi=3.14159; //此时并未将Pi放入ROM中 ...... 

 double i=Pi; //此时为Pi分配内存,以后不再分配! 

 double I=PI; //编译期间进行宏替换,分配内存 

 double j=Pi; //没有内存分配 

 double J=PI; //再进行宏替换,又一次分配内存! 

 const定义常量从汇编的角度来看,只是给出了对应的内存地址,而不是象#define一样给出的是立即数,所以,const定义的常量在程序运行过程中只有一份拷贝(因为是全局的只读变量,存在静态区),而 #define定义的常量在内存中有若干个拷贝。

(5) 提高了效率。 编译器通常不为普通const常量分配存储空间,而是将它们保存在符号表中,这使得它成为一个编译期间的常量,没有了存储与读内存的操作,使得它的效率也很高。

(6) 宏替换只作替换,不做计算,不做表达式求解;

 宏预编译时就替换了,程序运行时,并不分配内存。

const 与 #define的比较

 C++ 语言可以用const来定义常量,也可以用 #define来定义常量。但是前者比后者有更多的优点:

(1) const常量有数据类型,而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换,没有类型安全检查,并且在字符替换可能会产生意料不到的错误(边际效应)。

(2) 有些集成化的调试工具可以对const常量进行调试,但是不能对宏常量进行调试。

l 【规则5-2-1】在C++ 程序中只使用const常量而不使用宏常量,即const常量完全取代宏常量。

5.3 常量定义规则

l 【规则5-3-1】需要对外公开的常量放在头文件中,不需要对外公开的常量放在定义文件的头部。为便于管理,可以把不同模块的常量集中存放在一个公共的头文件中。

l 【规则5-3-2】如果某一常量与其它常量密切相关,应在定义中包含这种关系,而不应给出一些孤立的值。

例如:

const float RADIUS = 100;

const float DIAMETER = RADIUS * 2;

5.4 类中的常量

有时我们希望某些常量只在类中有效。由于#define定义的宏常量是全局的,不能达到目的,于是想当然地觉得应该用const修饰数据成员来实现。const数据成员的确是存在的,但其含义却不是我们所期望的。const数据成员只在某个对象生存期内是常量,而对于整个类而言却是可变的,因为类可以创建多个对象,不同的对象其const数据成员的值可以不同。

 不能在类声明中初始化const数据成员。以下用法是错误的,因为类的对象未被创建时,编译器不知道SIZE的值是什么。

 class A

 {…

 const int SIZE = 100; // 错误,企图在类声明中初始化const数据成员

 int array[SIZE]; // 错误,未知的SIZE

 };

const数据成员的初始化只能在类构造函数的初始化表中进行,例如

 class A

 {…

 A(int size); // 构造函数

 const int SIZE ; 

 };

 A::A(int size) : SIZE(size) // 构造函数的初始化表

 {

 …

 }

 A a(100); // 对象 a 的SIZE值为100

 A b(200); // 对象 b 的SIZE值为200

 怎样才能建立在整个类中都恒定的常量呢?别指望const数据成员了,应该用类中的枚举常量来实现。例如

 class A

 {…

 enum { SIZE1 = 100, SIZE2 = 200}; //枚举常量

 int array1[SIZE1];

 int array2[SIZE2];

 };

  枚举常量不会占用对象的存储空间,它们在编译时被全部求值。枚举常量的缺点是:它的隐含数据类型是整数,其最大值有限,且不能表示浮点数(如PI=3.14159)。sizeof(A) = 1200;其中枚举部长空间。

 enum EM { SIZE1 = 100, SIZE2 = 200}; //枚举常量 sizeof(EM) = 4;

const

const T 定义一个常量,声明的同时必须进行初始化。一旦声明,这个值将不能被改变。

const T* 指向常量的指针,不能用于改变其所指向的对象的值。

const int* 与int* const的区别

const int* 指针指向的对象不可以改变,但指针本身的值可以改变;

int* const 指针本身的值不可改变,但其指向的对象可以改变。

const int* const 是一个指向常量对象的常量指针,即不可以改变指针本身的值,也不可以改变指针指向的对象。

sizeof

char、signed char和unsigned char的sizeof值为1

sizeof有三种语法形式,如下:

1) sizeof( object ); // sizeof( 对象 );

2) sizeof( type_name ); // sizeof( 类型 );

3) sizeof object; // sizeof 对象;(建议不用)

函数、不能确定类型的表达式以及位域(bit-field)成员不能被计算sizeof值

sizeof的计算发生在编译时刻,所以它可以被当作常量表达式使用如:

char ary[ sizeof( int ) * 10 ]; // ok

最新的C99标准规定sizeof也可以在运行时刻进行计算

一般的,在32位编译环境中,sizeof(int)的取值为4。一个指针变量的返回值必定是4(注意结果是以字节为单位),可以预计,在将来的64位系统中指针变量的sizeof结果为8

字节对齐的细节和编译器实现相关,但一般而言,满足三个准则:

1) 结构体变量的首地址能够被其最宽基本类型成员的大小所整除;

2) 结构体每个成员相对于结构体首地址的偏移量(offset)都是成员大小的整数倍,

如有需要编译器会在成员之间加上填充字节(internal adding);

3) 结构体的总大小为结构体最宽基本类型成员大小的整数倍,如有需要编译器会在最

末一个成员之后加上填充字节(trailing padding)。

联合体的sizeof

结构体在内存组织上是顺序式的,联合体则是重叠式,各成员共享一段内存,所以整个

联合体的sizeof也就是每个成员sizeof的最大值。结构体的成员也可以是复合类型,这

里,复合类型成员是被作为整体考虑的。

所以,下面例子中,U的sizeof值等于sizeof(s)。

union U

{

int i;

char c;

S1 s;

};

多态

C++多态性是通过虚函数来实现的,虚函数允许子类重新定义成员函数,而子类重新定义父类的做法称为覆盖(override),或者称为重写。(这里我觉得要补充,重写的话可以有两种,直接重写成员函数和重写虚函数,只有重写了虚函数的才能算作是体现了C++多态性)而重载则是允许有多个同名的函数,而这些函数的参数列表不同,允许参数个数不同,参数类型不同,或者两者都不同。编译器会根据这些函数的不同列表,将同名的函数的名称做修饰,从而生成一些不同名称的预处理函数,来实现同名函数调用时的重载问题。但这并没有体现多态性。

多态与非多态的实质区别就是函数地址是早绑定还是晚绑定。如果函数的调用,在编译器编译期间就可以确定函数的调用地址,并生产代码,是静态的,就是说地址是早绑定的。而如果函数调用的地址不能在编译器期间确定,需要在运行时才确定,这就属于晚绑定。

那么多态的作用是什么呢,封装可以使得代码模块化,继承可以扩展已存在的代码,他们的目的都是为了代码重用。而多态的目的则是为了接口重用。也就是说,不论传递过来的究竟是那个类的对象,函数都能够通过同一个接口调用到适应各自对象的实现方法。

最常见的用法就是声明基类的指针,利用该指针指向任意一个子类对象,调用相应的虚函数,可以根据指向的子类的不同而实现不同的方法。如果没有使用虚函数的话,即没有利用C++多态性,则利用基类指针调用相应的函数的时候,将总被限制在基类函数本身,而无法调用到子类中被重写过的函数。因为没有多态性,函数调用的地址将是一定的,而固定的地址将始终调用到同一个函数,这就无法实现一个接口,多种方法的目的了。

令人迷惑的隐藏规则

本来仅仅区别重载与覆盖并不算困难,但是C++的隐藏规则使问题复杂性陡然增加。

这里“隐藏”是指派生类的函数屏蔽了与其同名的基类函数,规则如下:

(1)如果派生类的函数与基类的函数同名,但是参数不同。此时,不论有无virtual

关键字,基类的函数将被隐藏(注意别与重载混淆)。

(2)如果派生类的函数与基类的函数同名,并且参数也相同,但是基类函数没有virtual

关键字。此时,基类的函数被隐藏(注意别与覆盖混淆)。

C++纯虚函数

 一、定义

 纯虚函数是在基类中声明的虚函数,它在基类中没有定义,但要求任何派生类都要定义自己的实现方法。在基类中实现纯虚函数的方法是在函数原型后加“=0”

 virtual void funtion()=0

二、引入原因

 1、为了方便使用多态特性,我们常常需要在基类中定义虚拟函数。

 2、在很多情况下,基类本身生成对象是不合情理的。例如,动物作为一个基类可以派生出老虎、孔雀等子类,但动物本身生成对象明显不合常理。

 为了解决上述问题,引入了纯虚函数的概念,将函数定义为纯虚函数(方法:virtual ReturnType Function()= 0;),则编译器要求在派生类中必须予以重写以实现多态性。同时含有纯虚拟函数的类称为抽象类,它不能生成对象。这样就很好地解决了上述两个问题。

三、相似概念

 1、多态性

 指相同对象收到不同消息或不同对象收到相同消息时产生不同的实现动作。C++支持两种多态性:编译时多态性,运行时多态性。

 a、编译时多态性:通过重载函数实现

 b、运行时多态性:通过虚函数实现。

多态分为两种:通用的多态和特定的多态。两者的区别是前者对工作的类型不加限制,允许对不同类型的值执行相同的代码;后者只对有限数量的类型有效,而且对不同类型的值可能要执行不同的代码。

 通用多态又分为参数多态(parametric)和包含多态(Inclusion Polymorphism);特定多态分为过载多态(overloading)和强制多态(coercion)。

 强制多态(coercion):编译程序通过语义操作,把操作对象的类型强行加以变换,以符合函数或操作符的要求。程序设计语言中基本类型的大多数操作符,在发生不同类型的数据进行混合运算时,编译程序一般都会进行强制多态。程序员也可以显示地进行强制多态的操作(Casting)。举个例子,比如,int+double,编译系统一般会把int转换为double,然后执行double+double运算,这个int-》double的转换,就实现了强制多态,即可是隐式的,也可显式转换。

 过载多态(overloading):同一个名(操作符﹑函数名)在不同的上下文中有不同的类型。程序设计语言中基本类型的大多数操作符都是过载多态的。通俗的讲法,就是c++中的函数重载。在此处中“overload”译为“过载”,其实就是所谓的“重载”,也许“overload”就应翻译为“过载,重载”吧,那“override”就只能是“覆盖”了。

 包含多态(Inclusion Polymorphism):同样的操作可用于一个类型及其子类型。(注意是子类型,不是子类。)包含多态一般需要进行运行时的类型检查。

 需要注意的地方:包含多态的操作存在着逆单调(Anti-mornotonic)。即一个类型t上的操作,当其定义域缩小成t的一个子类型时,其值域应不小于t.

  参数多态(parametric),采用参数化模板,通过给出不同的类型参数,使得一个结构有多种类型。(类似模板类吧!)

 2、虚函数

 虚函数是在基类中被声明为virtual,并在派生类中重新定义的成员函数,可实现成员函数的动态覆盖(Override)

 3、抽象类

 包含纯虚函数的类称为抽象类。由于抽象类包含了没有定义的纯虚函数,所以不能定义抽象类的对象。

重载函数的调用匹配

现在已经解决了重载函数命名冲突的问题,在定义完重载函数之后,用函数名调用的时候是如何去解析的?为了估计哪个重载函数最适合,需要依次按照下列规则来判断:

1.精确匹配:参数匹配而不做转换,或者只是做微不足道的转换,如数组名到指针、函数名到指向函数的指针、T到const T;

2.提升匹配:即整数提升(如bool 到 int、char到int、short 到int),float到double使用标准转换匹配:如int 到double、double到int、double到long double、Derived*到Base*、T*到void*、int到unsigned int;

3.使用用户自定义匹配;

4.使用省略号匹配:类似printf中省略号参数

编译器是如何解析重载函数调用的?

编译器实现调用重载函数解析机制的时候,肯定是首先找出同名的一些候选函数,然后从候选函数中找出最符合的,如果找不到就报错。下面介绍一种重载函数解析的方法:编译器在对重载函数调用进行处理时,由语法分析、C++文法、符号表、抽象语法树交互处理,交互图大致如下:

这个四个解析步骤所做的事情大致如下:

由匹配文法中的函数调用,获取函数名;

获得函数各参数表达式类型;

语法分析器查找重载函数,符号表内部经过重载解析返回最佳的函数

语法分析器创建抽象语法树,将符号表中存储的最佳函数绑定到抽象语法树上

下面我们重点解释一下重载解析,重载解析要满足前面《3、重载函数的调用匹配》中介绍的匹配顺序和规则。重载函数解析大致可以分为三步:

根据函数名确定候选函数集

从候选函数集中选择可用函数集合

从可用函数集中确定最佳函数,或由于模凌两可返回错误

面向对象的三个基本特征是:封装、继承、多态。其中,封装可以隐藏实现细节,使得代码模块化;继承可以扩展已存在的代码模块(类);它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用!

封装可以隐藏实现细节,使得代码模块化;封装是把过程和数据包围起来,对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念,即现实世界可以被描绘成一系列完全自治、封装的对象,这些对象通过一个受保护的接口访问其他对象。在面向对象编程上可理解为:把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让可信的类或者对象操作,对不可信的进行信息隐藏。

继承是指这样一种能力:它可以使用现有类的所有功能,并在无需重新编写原来的类的情况下对这些功能进行扩展。其继承的过程,就是从一般到特殊的过程。

通过继承创建的新类称为“子类”或“派生类”。被继承的类称为“基类”、“父类”或“超类”。要实现继承,可以通过“继承”(Inheritance)和“组合”(Composition)来实现。在某些 OOP 语言中,一个子类可以继承多个基类。但是一般情况下,一个子类只能有一个基类,要实现多重继承,可以通过多级继承来实现。

继承的实现方式?

继承概念的实现方式有三类:实现继承、接口继承和可视继承。

1. 实现继承是指使用基类的属性和方法而无需额外编码的能力;

2. 接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力;

3. 可视继承是指子窗体(类)使用基窗体(类)的外观和实现代码的能力。

CExample(const CExample& C)就是我们自定义的拷贝构造函数。可见,拷贝构造函数是一种特殊的构造函数,函数的名称必须和类名称一致,它必须的一个参数是本类型的一个引用变量

在C++中,下面三种对象需要调用拷贝构造函数!

1. 对象以值传递的方式传入函数参数

2. 对象以值传递的方式从函数返回

3. 对象需要通过另外一个对象进行初始化

1. 默认拷贝构造函数

 很多时候在我们都不知道拷贝构造函数的情况下,传递对象给函数参数或者函数返回对象都能很好的进行,这是因为编译器会给我们自动产生一个拷贝构造函数,这就是“默认拷贝构造函数”,这个构造函数很简单,仅仅使用“老对象”的数据成员的值对“新对象”的数据成员一一进行赋值,它一般具有以下形式:

拷贝构造函数没有处理静态数据成员。

浅拷贝,指的是在对象复制时,只对对象中的数据成员进行简单的赋值,默认拷贝构造函数执行的也是浅拷贝。大多情况下“浅拷贝”已经能很好地工作了,但是一旦对象存在了动态成员,那么浅拷贝就会出问题了。

在销毁对象时,两个对象的析构函数将对同一个内存空间释放两次,这就是错误出现的原因。我们需要的不是两个p有相同的值,而是两个p指向的空间有相同的值,解决办法就是使用“深拷贝”。

typedef

typedef 最简单使用 typedef long byte_4;

typedef 修饰数组

typedef char mySizes[100];    

mySizes xxx;  

typedef char [100] mySizes; //error 

typedef 修饰指针

typedef char * pstr; 

int mystrcmp(pstr, pstr); 

int mystrcmp(const pstr, const pstr); //error 

typedef const char * cpstr;  

int mystrcmp(cpstr, cpstr); // 现在是正确的 

在结构中包含指向它自己的指针

typedef struct tagNode  

{  

 char *pItem; 

 pNode pNext; // error 

} *pNode;

typedef struct tagNode  

 char *pItem; 

 struct tagNode *pNext;  

} *pNode;  


// 2)  

typedef struct tagNode* pNode;  

struct tagNode  

 char *pItem; 

 pNode pNext; 

}; 

//注意:在这个例子中,你用 typedef 给一个还未完全声明的类型起新名字。C语言编译器支持这种做法。 


// 3)规范做法:  

struct tagNode  

 char *pItem;  

 struct tagNode *pNext;  

}; 

typedef struct tagNode *pNode;  

通常讲,typedef要比#define要好,特别是在有指针的场合。

typedef char* pStr1;  

#define pStr2 char *  

pStr1 s1, s2; // char* s1; char* s2;  

pStr2 s3, s4; // char* s3, s4;即 char s4; 这句打不到预期效果,必须写成 pStr2 s3, *s4

浮点数的二进制转换

Sign(1bit):表示浮点数是正数还是负数。0表示正数,1表示负数

Exponent(8bits):指数部分。类似于科学技术法中的M*10^N中的N,只不过这里是以2为底数而不是10。需要注意的是,这部分中是以2^7-1即127,也即01111111代表2^0,转换时需要根据127作偏移调整。

Mantissa(23bits):基数部分。浮点数具体数值的实际表示。

内联函数通常就是将它在程序中的每个调用点上“内联地”展开,假设我们将 max 定义为内联函数:

复制代码 代码如下:

inline int max(int a, int b)

{

 return a > b ? a : b;

}

则调用: cout<

在编译时展开为: cout<<(a > b ? a : b)<

从而消除了把 max写成函数的额外执行开销

你可能感兴趣的:(C笔记)