c++语法：只要基类是虚函数，子类里的那个函数默认就是虚函数。 
2。c++是静态类型编译的语言，编译时，delete pb，就只看pb的类型是什么，pb的析构如果不是虚函数，就照常规调用了，因为编译器不知道基类派生了多少子类，它只知道虚函数就通过虚表，普通函数就直接调用。
只要你准备让人继承，就设成虚拟的，因为你无从预料客户如何使用这个类。
http://blog.csdn.net/pandaxcl/category/189570.aspx

为了方便查阅复习，将自己原来撰写的博文进行整理，C++语法专栏目录如下：
C++语法学习(0) —— 基础语法上与C的异同

C++语法学习(1) —— 封装

C++语法学习(2) —— 继承

C++语法学习(3) —— 多态

C++语法学习(4) —— 模板

C++语法学习(5) —— STL

C++语法学习(6) —— string

C++语法学习(7) —— vector
(持续更新中)

本文由 @lonelyrains 出品，转载请注明出处。 
文章链接： http://blog.csdn.net/lonelyrains/article/details/46120095



1、构造函数的基类参数
假设继承关系CDialog->CBaseDialog->CDeriveDialog
CDialog: :CDialog(UINT nIDTemplate, CWnd* pParentWnd = NULL)
CBaseDialog::CBaseDialog(UINT nIDTemplate, CWnd* pParentWnd = NULL)
    :CDialog(nIDTemplate, CWnd* pParentWnd)
CDeriveDialog ::CDeriveDialog(UINT nIDTemplate, CWnd* pParentWnd = NULL)
    :CBaseDialog(nIDTemplate, CWnd* pParentWnd)
[注：当已有的构造函数参数不完整时，不能使用如下连续构造的形式（假设CBaseDialog的构造没有nIDTemplate参数），而是应该重定义CBaseDialog的构造函数：
CDeriveDialog ::CDeriveDialog(UINT nIDTemplate, CWnd* pParentWnd = NULL)
    :CBaseDialog(CWnd* pParentWnd):CDialog(nIDTemplate, pParentWnd)
]
 
2、虚函数声明
虚函数在父类中声明成为了虚函数，子类中无需再声明一次，也具有虚函数属性
 
3、子类虚函数中调用父类的实现
子类虚函数中调用父类的实现直接使用Parent::func方式调用
 
2、3的示例代码如下，其中print1函数用来说明第2点，print函数用来说明第3点
 
class Parent
{
public :
    virtual void print()
    {
         printf("Parent\r\n");
    }
    virtual void print1()
    {
         printf("Parent\r\n");
    }
};

class Son : public Parent
{
public :
    virtual void print()
    {
         printf("Parent\r\n");
         Parent::print();
    }
    void print1()
    {
         printf("Parent\r\n");
    }
};

void main()
{
    Son son;
    son.print();

    Parent *person = new Son;
    person->print1();
    delete person;
}

c++语法大全
一、变量和简单数据类型
1.变量名只能包含字母、数字和下划线。可以以字母和下划线开头，但是不能从数字开头；变量名不能包含空格
2.数据类型–字符串
字符串可以用双引号或者单引号括起来，两者作用一样。具体选择哪种，要看字符串里面的内容，如果字符串里面包含单引号，那么外面就要使用双引号；如果字符串里面包含双引号，那么就用单引号括起来。
3.字符串函数
title()–以首字母大写的方式显示每个单词
title.upper()–全部大写
title.lower()–全部小写
4.拼接字符串–用"+"号
a=“hello”
b=“world”
print(a+","+b)
输出hello,world
5.指标符–\t  换行符–\n
6.字符串空白处理
rstrip()–删除末尾空白
lstrip()–删除开头空白
strip–删除两端空白
7.数字的四则运算没有什么特别的
8.字符串函数–str()
age=23
str(age)
9.注释符号
单行注释–#
多行注释–"""……"""
二、列表
1.列表类似于C语言的数组，将同类事物放在一个数组里面
string = [‘abc’ , ‘bcd’ , ‘efg’]
print(string)
输出： [‘abc’ , ‘bcd’ , ‘efg’]
还可以直接定义空列表string[]
2.访问列表元素
类似于C语言的数组，string[0]，即可访问第一个元素
访问最后一个元素–string[-1]
3.修改元素
string[1] = ‘apple’
4.添加元素
在末尾添加–string.append(‘student’)
5.插入元素
string.insert(0,‘banana’），则banana插入到了列表开头，其他元素后移
6.删除元素
del string[0]
使用del删除的元素，将无法再次访问
string2 = string.pop()
pop函数删除了string末尾的元素，并将其赋值给string2
如果要删除制定位置的元素，只需string.pop(2)
根据值删除元素
string.remove(‘apple’)
remove只删除第一个制定的值，如果要删除列表中所有匹配的值，则需用循环
7.排序
string.sort()–按字母顺序排
string.sort(reverse=True)–按字母逆序排
sorted(string)–临时排序，即排序只有在用运行此句代码时有效，执行下一行代码时字符串又变成原来的顺序
8.反转列表元素的排列顺序
string.reverse()
9.列表长度–len(string)
三、操作列表
1.遍历整个列表–for循环
for k in string:
print(k)
相当于C语言：
for（k=string[i];i<strlen(string);i++）
{
printf(k);
}
2.创建数值列表
range(1,5)–左闭右开，1,2,3,4
for value in range(1,5)
使用list()直接将range()转换成列表
number = list(range(1,6))
print(number)
输出：[1,2,3,4,5]
range指定步长–range(2,11,2)–从2开始数，不断加2，直到达到11或超过11
2,4,6,8,10
3.平方–**
value=a**2
4.列表解析
squares = [value**2 for value in

range(1,11)]
print(squares)
[1,4,9,16,25,36,49,64,81,100]
C语言：
for(i=1;i<11;i++)
{
squares= i*I;
printf(squares);
}
5.切片–使用列表的一部分
要创建切片，可指定要使用的第一个元素和最后一个元素的索引。与range一样，Python在到达你指定的第二个索引前面的元素停止。
letter=[‘a’ , ‘b’ , ‘c’ , ‘d’ , ‘e’ , ‘f’]
letter[0:3]–[‘a’ , ‘b’ , ‘c’]
letter[1:4]–[‘b’ , ‘c’ , ‘d’]
letter[:3]–[‘a’ , ‘b’ , ‘c’]–没有指定第一个索引，就从第一个元素开始
letter[1:]–[‘b’ , ‘c’ , ‘d’ , ‘e’ , ‘f’]–没有指定最后一个索引，就在最后一个元素结束
letter[-3:]–最后三个元素
6.遍历切片
切片是原列表的一个子集，也是一个列表，他的基本操作和列表操作一样
7.复制列表
letter2=letter[:]–只需省略起始索引即可
8.元组
列表的元素可修改，而元组的元素不可修改
9.定义元组
使用圆括号定义–dim=(200,50)
print(dim[0])
print(dim[1])
10.修改元组变量
dim=(200,50)
dim=(500,90)
print(dim[1])
90
这个不是修改元组的元素，而是修改整个元组，使他变成一个新的元组
四、if语句
1.例子
for car in cars：    if car == “bmw”        print(car.upper()     elif car==“ccd”        print(car.lower() )    else

print(car.title() )
2.判断符号
==

!=  and  >=

or
a>=0 and b>=3
3.检查特定值不是否不包含在列表中
if student not in users:
4.检查列表是否为空
if cars：
print(cars[0])
五、字典
1.类似于C语言的结构体
student_1 = {‘name’ : ‘Tony’ , ‘age’:5}
print(student_1[‘name’])
print(student_1[‘age’])
Tony
5
2.添加字典值
字典是一种动态结构，可随时在其中添加键–值对。
student_1[‘sex’] = ‘M’
print(student_1)
{‘name’ : ‘Tony’ , ‘age’:5 , ‘sex’ = ‘M’ }
3.修改字典的值
student_1[‘age’]=6
4.删除值
del student_1[‘name’]
print(student_1)
{‘age’:5 , ‘sex’ = ‘M’ }
5.遍历字典
user_0 = {
‘username’: ‘efermi’
‘first’: ‘enrico’
‘last’: ‘fermi’
}
for k, v in user_0.items():
print("\nkey: " +k)
print("\nvalue" +v)
key: last
value: fermi
key:

first
value: enrico
key: username
value: efermi
PS:遍历字典时，顺序可能会与存储的顺序不一样
6.遍历字典的全部键
for name in student_1.keys():
7.遍历字典的所有值
student_1.values()
8.剔除重复项
set(student_1.values() )
9.嵌套–在列表中存储字典
将一系列字典存储在列表中，或将列表作为值存储在字典中。
alien_0={‘color’:‘green’,‘point’:5}
alien_1={‘color’:‘yellow’,‘point’:10}
alien_2={‘color’:‘red’,‘point’:15}
aliens=[alien_0,alien_1,alien_2]
for alien in aliens:
print(alien)
{‘color’: ‘green’, ‘point’: 5}
{‘color’: ‘yellow’, ‘point’: 10}
{‘color’: ‘red’, ‘point’: 15}
10.嵌套–在字典中存储列表
五、用户输入和while循环
1.输入–input()
a=input(“please input a number”)
相当于C语言：
printf(“please input a number”);
scanf("%d",&a);
2.int类型转换
a=input(“please input a number”)
a=int(a)
3.求模运算符%
两个数相除并返回余数
4%3=1
4%4=0
4.while循环
cnt=1
while cnt <=5:
print(cnt)
cnt+=1
5.使用break退出整个循环
while True:
if … :
break
else
…
6.continue–退出当前循环
六、函数
1.函数的定义及调用
def

greet(): #定义函数
print(‘hello’)
greet() #调用函数
2.传递参数
def greet (username): #定义函数
print(‘hello,’+username)
greet(‘jenny’)  #调用函数
3.位置实参–位置很重要，参数一

一对应
调用函数时，Python必须将函数调用中的每个实参都关联到函数定义中的一个形参。为此，最简单的关联方式就是基于实参的顺序。
定义：def des(animal_type, pet_name):
调用：def des(‘cat’, ‘harry’)
4.关键字实参–传递给函数的名称–值对,顺序可以变
定义：def des(animal_type, pet_name):
调用：def des(animal_type=‘cat’, pet_name=

‘harry’)
5.默认值–给形参指定默认值后，可在函数调用中省略相应的实参
定义：def des(animal_type, pet_name= ‘harry’)
调用：def des(animal_type=‘cat’)
6.返回值–同C语言，return
7.返回字典–就像返回数组
return 字典名/列表名
8.传递列表–参数直接就是列表名，就像传数组一样
9.在函数中修改列表
将列表传递给函数后，函数就可对其进行修改。在函数中对这个列表所做的任何修改都是永久性的
10.禁止函数修改列表
可以传递列表的切片(相当于复制一个列表)
fun(list[:])
11.传递任意数量的实参
def fun(*toppings)
*星号让Python创建一个名为toppings的空元祖，并将所有值都封装到这个元组中
12.将函数存在模块中，再导入整个模块
import fun
13.使用as给函数/模块制定别名
14.导入模块中的所有函数
from mokuai import *
七、类
1.编写和创建类
根据Dog类创建的每个实例都将存储名字和年龄。我们赋予了每条小狗蹲下sit()和打滚roll_over()的能力
class Dog():    ‘’‘一次模拟小狗的简单尝试’’’    def init(self,name,age):        ‘’‘初始化属性name和age’’’        self.name =

name        self.age=age    def sit(self):        ‘’‘模拟小狗被命令时蹲下’’’        print(self.name.title()+’ is now

sitting.’)    def roll_over(self):        ‘’‘模拟小狗被命令时打滚’’’        print(self.name.title()+’ rolled

over!’)
根据约定，在Python中，首字母大写的名称指的是类。这个类定义中的括号是空的，因为我们要从空白创建这个类。
类中的函数称为方法，与普通函数的规则一样，但是调用方式不一样。
（1）方法  init()
我们将方法_init_()定义成了包含三个形参：self、name、age。在这个方法的定义中，形参self是必不可少的，还必须位于其他形参的前面。因为Python调用这个_init_()方法来创建Dog实例时，将自动传入实参self。每个与类相关联的方法调用都自动传递实参self，他是指一个指向实例本身的引用，让实例能够访问类中的属性和方法。
我们创建Dog实例时，Python将调用Dog类的方法_init_().我们将通过实参向Dog传递名字和年龄，self会自动传递，因此我们不需要传递他。没当我们根据Dog类创建实例时，都只需给最后两个形参（name和age）提供值。
self.name=name
self.age=age
以self为前缀的变量都可供类中的所有方法使用，我们还可以通过类的任何实例来访问这些变量。self.name=name获取存储在形参name中的值，并将其存储到变量name中，然后该变量被关联到当前创建的实例。
2.访问属性
类似于C语言的结构体成员，这里用一个句点来访问属性。my_dog.name
3.调用方法
my_dog=Dog(‘willie’,6)
my_dog.sit()
my_dog.roll_over()
4.修改属性的值
通过实例进行修改
   通过方法进行设置

   通过方法进行递增（增加特定的值）

5.子类的方法_ init _()
创建子类的实例时，Python首先需要完成的任务是给父类的所有属性赋值。
class Car():
‘’‘一堆关于Car类的代码略过…’’’
class Electricar(Car):
‘’‘子类电动车的括号里包含父类的名称’’’
‘’‘创建子类时，父类必须包含在当前文件中，且位于子类前面’’’
6.给子类定义属性和方法
7.重写父类的方法
8.将实例用作属性
关于子类和父类的用法自己去百度，这里不详说
9.将模块中的类导入到主程序中
from car import Car —将car文件中的Car类导入到当前文件
from car import Car，ElectricCar–导入多个类
import car–导入car模块
from modern_name import *–导入所有类
八、文件和异常
1.读取整个文件
with open (‘demo.txt’) as file_object:
contents=file_object.read()
print(contents)
关键字with在不需要访问文件后将其关闭，在整个程序中，我们调用了close(),但没有调用close()。你也可以调用open（）和close（）来打开和关闭文件，但这样做时，如果程序存在bug，导致close（）语句未执行，问价将不会关闭。
2.文件路径
file_name = ‘text_files\filename.txt’
with open(file_name) as file_object
3.逐行读取
for line in file_object:
print(line)
4.创建一个包含文件各行内容的列表
使用关键字with时，open（）返回的文件对象只在with代码块内可用。如果要在with代码块外访问文件的内容，可在with代码块内将文件各行存储在一个列表中，并在with代码块外使用该列表。
file_name=‘text_files\filename.txt’
with

open  (file_name) as file_object:
lines=file_object.readlines()
for line in lines:
print(line.rstrip())
5.写入文件
filename=‘programming.txt’
with

open  (filename,‘w’)  as

file_object:  #在文件名后加一个参数。默认是只读
file_object.write(‘I love programming.’)
4.异常
如果你编写了了处理该异常的代码，程序将继续运行，如果未对异常进行处理，程序将终止，并显示一个traceback，其中包含异常的报告。
具体自己上网查
5.存储数据
模块json让你能够将简单的Python数据结构转储到文件中，并在程序再次运行时加载该文件中的数据。
函数json.dump()接受两个实参：要存储的数据以及可用于存储数据的文件对象
6.重构–将代码进行修改
九、测试代码