C++和C的不同之处

1.变量的使用

在C语言中局部变量必须在执行代码的前面，C++中变量的定义可以放到程序块的任何地方 eg for c++:

for(int i = 0 ; i < 10 ; i++){}

2.严格了函数的声明

C语言中函数的声明很随意，C++中摒弃了这种随意的定义

C: int add();//可以将参数直接省略 C++: int add(int a,int b);

3.增加了重载机制

重载是对一个名字或者符号多重意义的解释

4.函数缺省参数

C++中允许函数进行缺省 eg:

声明： int f(int a, int b=2){ return a+b; } 调用下面两个结果相同： f(1,2); f(1);

5.更加方便动态存储分配

C++中提供动态分配的new和delete，增强C中的malloc(),free()

6.增加内联函数

C++中用内联函数取代C中的宏

C: #define MAX(a，b) ((a)>(b)?(a):(b)) C++: inline int MAX(int a，int b) { 　　return a>b?a:b； }

7.输入输出机制

C++保留了C的标准输入输出，并且提供了一套新的输入输出机制

C: printf("C"); C++: cout<<"C++"<<endl;

8.增设了面向对象的思想和处理

重点基础知识

1.指针数组

指针数组的元素类型是指针指针数组的元素存放对象的地址 类型 * 标识符 [ 表达式 ] ; int * pi [ 3 ] ;//其中int * 是每一个数组单元中存放的类型 float * pf [ 5 ] ;//其中float * 是每一个数组单元中存放的类型 char * ps [ 10 ] ;//其中char * 是每一个数组单元中存放的类型

2.指向数组的指针数组

double (*pf [3])[2] ; double a[2];

对比这两个：

double a[2]; a指向了一块具有两个元素的空间

然后类比推理，(*pf [3])是一个数组，那么pf[0]的内容指向了一个具有两个空间的单元

所以代码如下：

#include<iostream.h> void main(){ double aa [2] = { 1.1, 2.2 } ; double bb [2] = { 3.3, 4.4 } ; double cc [2] = { 5.5, 6.6 } ; double ( * pf [3] ) [2] ; pf [0] = & aa ; pf [1] = & bb ; pf [2] = & cc ; for ( int i = 0 ; i < 3 ; i ++ ){ for ( int j = 0 ; j < 2 ; j ++ ) cout << * ( * pf [ i ] + j ) << " " ; cout << endl ; } }

补充：

一维数组类型的定义格式 typedef <元素类型关键字><数组类型名>[<常量表达式>];

eg： typedef int vector[10];

使用的时候：

vector v1;相当于定义了一个有着10个int类型的数组。

所以上面代码改成：

#include<iostream.h> void main(){ typedef double aryType [2] ; aryType aa = { 1.1, 2.2 } ; aryType bb = { 3.3, 4.4 } ; aryType cc = { 5.5, 6.6 } ; aryType * pf [ 3 ] ; pf [0] = & aa ; pf [1] = & bb ; pf [2] = & cc ; for ( int i = 0 ; i < 3 ; i ++ ){ for ( int j = 0 ; j < 2 ; j ++ ) cout << * ( * pf [ i ] + j ) << " " ; cout << endl ; } }

3.指向函数的指针数组

// func.h #ifndef FUNC_H #define FUNC_H const float PI = 3.1415; float Square_Girth ( float l ) { return 4 * l ; } float Square_Area ( float l ) { return l * l ; } float Round_Girth ( float r ) { return 2 * PI * r ; } float Round_Area ( float r ) { return PI * r * r ; } typedef float ft ( float ) ; #endif //ex4_8.cpp #include<iostream.h> #include " func.h " void main() { int i ; float x = 1.23 ; ft * pfun [ 4 ] ; pfun [ 0 ] = Square_Girth ; pfun [ 1 ] = Square_Area ; pfun [ 2 ] = Round_Girth ; pfun [ 3 ] = Round_Area ; for ( i = 0 ; i < 4 ; i ++ ) cout << ( * pfun [ i ] ) ( x ) << endl ; return ; }

其中typedef float ft ( float ) ;是定义函数

4.new + delete

int * p1 = new int ; int * p4 = new int [4] ; delete p1 ; delete [] p4 ;

4.new建立动态数组

int * p = NULL; p = new int [10] ; delete [] p ;

特别的：

#include<iostream.h> void App( int * & pa , int n ) ; void main(){ int *ary = NULL, *t , i, n ; cout<<"n= "; cin>>n; App( ary, n ); for( i = 0; i<n; i++ ) {ary[i] = 10 + i ; cout<<ary[i]<<" "; } delete []ary; } void App( int * & pa , int len ){ pa = new int [len] ; if( pa == NULL ){ cout << "allocation faiure\n"; return ; } for( int i = 0; i<len; i++ ) pa[i] = 0 ; }

形参 int *pa是传地址值参数 调用函数时实参ary的值（NULL）赋给形参变量pa 函数App执行new操作把地址写入pa，与ary无关 函数返回后，ary不能获得动态数组的地址

5.字符数组

生成： char *string = "Student" ; 操作: strcpy ( string , "Student" ) ; char * name [ 5 ] = { "Li Hua" , "He Xiao Ming" , "Zhang Li" , "Sun Fei" , "Chen Biao" }

C++中的核心基础

---

声明： class AA { public: AA() { …… } ~AA() { …… } …… }; 调用： AA t1, t2 ;

使用初始构造：

使用“初始式”的构造函数形式为： 构造函数名 (变元表): 数据成员1 (变元表), … , 数据成员n (变元表) { /* …… */ }

对象成员初始化

#include<iostream.h> class A { public : A ( int x ) : a ( x ) { } int a ; } ; class B { public : B( int x, int y ) : aa( x ), b( y ) { } void out() { cout << "aa = " << aa.a << endl << "b = " << b << endl ; } private : int b ; A aa ; } ; void main (){ B objB( 3,5); objB . out ( ) ; }

C++中运算符的重载

可以重载的运算符 + - * / % ^ & | ~ ! = < > += -= *= /= % ^= &= |= << >> >>= <<= == != <= >= && || ++ -- ->* ‘ -> [] () new delete new[] delete[] 不能重载的算符 . :: .* ?: sizeof

语法形式：

类型 类名 :: operator op ( 参数表 ) { // 相对于该类定义的操作 }

举个例子：

这个例子中注意重载unsigned int operator() () ;其中运算符()

#include<iostream.h> #include<stdlib.h> class Calculator { public: Calculator() { value = 0 ; } ; void operator ++ () ; void operator -- () ; unsigned int operator() () ; private: unsigned int value; }; void main() { Calculator Counter ; int i ; for( i = 0 ; i < 5 ; i ++ ) { ++ Counter; cout << "\n Counter = " << Counter() ; } for( i = 0 ; i <= 5 ; i ++ ) { -- Counter; cout << "\n Counter = " << Counter() ; } }

实现：

void Calculator::operator ++ () { if ( value < 65535 ) value ++ ; else { cout << "\nData overflow !" << endl ; abort() ; } } void Calculator::operator --() { if ( value > 0 ) value -- ; else { cout << "\n Data overflow !" << endl ; abort() ; } } unsigned int Calculator::operator() () { return value ; }

重载下标运算符

重载格式 类型 类 :: operator[] ( 类型 ) ； 例 设 x 是类 X 的一个对象，则表达式 x [ y ] 可被解释为 x . operator [ ] ( y )

举个例子：

#include<iostream.h> class vector { public : vector ( int n ) { v = new int [ n ] ; size = n ; } ~ vector ( ) { delete [ ] v ; size = 0 ; } int & operator [ ] ( int i ) { return v [ i ] ; } private : int * v ; int size ; }; void main ( ){ vector a ( 5 ) ; a [ 2 ] = 12 ; cout << a [ 2 ] << endl ; }

多继承

语法：

class 派生类名 : 访问控制 基类名1 , 访问控制 基类名2 , … , 访问控制 基类名n { 数据成员和成员函数声明 }；

子类是在内存中拷贝了父类单元

代码：

class Base1 { public: Base1(int x) { value = x ; } int getData() const { return value ; } protected: int value; }; class Base2 { public: Base2(char c) { letter=c; } char getData() const { return letter;} protected: char letter; }; class Derived : public Base1, public Base2 { friend ostream &operator<< ( ostream &, const Derived & ) ; public : Derived ( int, char, double ) ; double getReal() const ; private : double real ; };

虚基类

通过代码：

这段代码的结果是调用了两次A的构造函数

#include < iostream.h > class A { public : A ( ) { cout << "class A" << endl ; } } ; class B : public A { public : B ( ) {cout << "class B" << endl ; } } ; class C : public A { public : C ( ) {cout << "class C" << endl ; } } ; class D : public B , public C { public : D ( ) {cout << "class D" << endl ; } } ; void main ( ) { D dd ; }

看下面代码：

只调用了一次A的构造函数

#include < iostream.h > class A { public : A ( ) { cout << "class A" << endl ; } } ; class B : virtual public A { public : B ( ) {cout << "class B" << endl ; } } ; class C : virtual public A { public : C ( ) {cout << "class C" << endl ; } } ; class D : public B , public C { public : D ( ) {cout << "class D" << endl ; } } ; void main ( ) { D dd ; }

虚函数与多态

派生类指针引用基类对象

派生类指针只有经过强制类型转换之后，才能引用基类对象 #include<iostream.h> #include<string.h> class Date { public: Date( int y, int m, int d ) { SetDate( y, m, d ); } void SetDate( int y, int m, int d ) { year = y ; month = m ; day = d ; } void Print() { cout << year << '/' << month << '/' << day << "; " ; } protected : int year , month , day ; } ; class DateTime : public Date { public : DateTime( int y, int m, int d, int h, int mi, int s ) : Date( y, m, d ) { SetTime( h, mi, s ); } void SetTime( int h, int mi, int s ) { hours = h; minutes = mi; seconds = s; } void Print() { ( ( Date * ) this ) -> Print();//对 this 指针作类型转换调用基类成员函数 cout << hours << ':' << minutes << ':' << seconds << '\n' ; } private: int hours , minutes , seconds ; }; void main() { DateTime dt( 2003, 1, 1, 12, 30, 0 ) ; dt.Print() ; }

析构函数的调用

当基类的指针指向派生类的对象，然后进行delete 基类指针的时候， 这个时候只是调用基类的析构函数，不会调用派生类的构造函数 #include<iostream.h> class A { public: ~A(){ cout << "A::~A() is called.\n" ; } } ; class B : public A { public: ~B(){ cout << "B::~B() is called.\n" ; } } ; void main() { A *Ap = new B ; B *Bp2 = new B ; cout << "delete first object:\n" ; delete Ap; cout << "delete second object:\n" ; delete Bp2 ; } 执行结果是： delete first object: A::~A() is called. delete second object: B::~B() is called. A::~A() is called.

在析构函数前面加上virtual试试：

#include<iostream.h> class A { public: ~A(){ cout << "A::~A() is called.\n" ; } } ; class B : public A { public: ~B(){ cout << "B::~B() is called.\n" ; } } ; void main() { A *Ap = new B ; B *Bp2 = new B ; cout << "delete first object:\n" ; delete Ap; cout << "delete second object:\n" ; delete Bp2 ; } 结果是： delete first object: B::~B() is called. A::~A() is called. delete second object: B::~B() is called. A::~A() is called.

纯虚函数

形式：

virtual 类型 函数名（参数表）= 0 ;

纯虚函数相当于Java中的接口，不能有实现，可以继承，继承如果实现的话，就可以产生对象，如果继承类没有实现则不能产生对象还是抽象类

举个栗子：

//Employee.h class Employee { public: Employee(const long,const char* ); virtual ~Employee(); const char * getName() const; const long getNumber() const; virtual double earnings() const=0; virtual void print() const; protected: long number; // 编号 char * name; // 姓名 };

函数模板与模板函数 形式：

template < 类型形式参数表 > 类型 函数名 （ 形式参数表 ） { 语句序列 }

简单函数模板使用：

#include <iostream.h> template < typename T > T max ( T a , T b ) { return a > b ? a : b ; } void main ( ) { cout << " max ( 3 , 5 ) is " << max ( 3 , 5 ) << endl ; cout << " max ( 'y' , 'e' ) is " << max ( 'y' , 'e' ) << endl ; cout << " max ( 9.3 , 0.5 ) is " << max ( 9.3 , 0.5 ) << endl ; }

重载函数模板

永远都是先精准匹配，然后不匹配在寻找模板

template <typename T> T Max( const T a, const T b ) { return a>b ? a : b ; } template <typename T> T Max( const T a, const T b , const T c) { T t ; t = Max(a, b) ; return Max ( t, c ) ; } int Max( const int a , const char b ) { return a>b ? a : b ; }

类模板

形式：

template <类型形式参数表> 类声明 template< typename Type > class TClass { // TClass的成员函数 private : Type DateMember ; //… };