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.重构–将代码进行修改

九、测试代码

vscode c++语法检查以及指定c++标准

下载插件 C/C++ Clang Command Adapter

​ 在extension中搜索并下载安装，使用时发现其语法检查不支持c++11 标准。需要在配置中指定。

在插件的配置中指定c++标准

在Cxxflags 中指定需要的c++标准即可。

配置完成后可以看到没有再显示语法错误了。

在考计算机的研究生考试中，经常需要学习C和C++这两门语言，大多数的人在大学期间已经学习了C语言，而C++跟C的基础语言又十分相似，我也是在学习的过程中找到了这些不同之处，希望对你有所帮助。

一、应用场合

C语言：C语言是结构化和模块化的语言，是面向过程的。当程序的规模较小时，C语言运用起来得心应手。但是当问题比较复杂、程序的规模比较大的时候，C语言就会展现出它的局限性。

C++：正是因为有大规模的程序需要去处理，C++就应运而生了。C++是由C发展而来的，与C语言兼容。​C++既可用于面向过程的结构化程序设计，也可用于面向对象的程序设计，是一种功能强大的混合型的程序设计语言。

二、语法的不同之处

1、头文件

C语言：

#include<stdio.h>  //标准输入、输出

*C语言中所有的头文件都带后缀 .h

C++：

#include<iostream>  //输入输出流所包含的头文件

using namespace std;  //C++标准库中的类和函数是在命名空间std中声明的

*C++标准库中的类和函数是在命名空间std中声明的，C++中有系统提供的头文件不带后缀 .h，用户自己编制的头文件可以有后缀 .h。

2、输入/输出函数

C语言：用一个例子说明一下：

	int a;

	double b;

	scanf("%d",&a);​//输入a的值

	scanf("%lf",&b);//输入b的值

	printf("a=%d\n",a);	//输出a的值

	printf("b=%6.2f\n",b); //输出b的值

	

%d和%f称为格式说明符，表示以此格式输出对应表达式的值，\n表示换行。%6.2f 中的6表示占六列，.2 表示输出对应浮点表达式值时只输出三位小数。

C++：也是用一个例子说明：

	int a=5;

	float b;​

	cin >>b;	//给变量b赋值

	cout << "a="<<a<<endl;  //输出a的值
	
	cout << "b="<<b<<endl;	//输出b的值 ​

	

cout必须要和”<<“一起使用，用于输出变量的值，cin必须要和”>>“一起使用，用于给变量赋值。我觉得C++中的输入输出流是很强大的，它不像C里面还要指定格式。endl表示换行。​

3、字符串

字符串是C++比C操作简单的一个点，它是在C++标准库中声明的一个字符串类。

C语言：

	char a[20]="changsha";

	char *p="changsha";

可以用上面两种方式 ，一种是用数组的方式存储字符串，另外一种是用字符串指针。这两种方法都有一个麻烦的地方就是，字符串的连接、比较啊等等都需要调用函数执行，比如strcmp函数、strcat函数、strcpy函数。

strlen：求字符串长度

strcmp：字符串比较

strcat：字符串连接

strcpy：字符串复制

C++：

	
#include <iostream>
#include <string>
 
using namespace std;
 
int main ()
{
   string str1 = "Hello";
   string str2 = "World";
   string str3;
   int  len ;
 
   // 复制 str1 到 str3
   str3 = str1;
   cout << "str3 : " << str3 << endl;
 
   // 连接 str1 和 str2
   str3 = str1 + str2;
   cout << "str1 + str2 : " << str3 << endl;
 
   // 连接后，str3 的总长度
   len = str3.size();
   cout << "str3.size() :  " << len << endl;
 
   return 0;
}

由此看来是不是方便了许多？

4、结构体和类

C语言：结构体

struct Student {   //声明了一个名为Student的结构体类型

	int num;

	char name[20];

	char sex;​
	
} ;

	Student stud1,stud2; //定义了两个结构体变量

C++：类

class Student{

  private：

       int num;

       char name[20];

       char sex;

  public:

       void display() { 

      		cout<<"num="<<num<<endl;

         	cout<<"name="<<name<<endl;

         	cout<<"sex="<<sex<<endl; ​
       }

   ​};

  Student stud1,stud2;//定义了两个Student类的对象

C++中保留了结构体，并且C++对struct进行了进一步的扩展，使struct在C++中可以和class一样当做类使用，而唯一和class不同的地方在于struct的成员默认访问修饰符是public，而class默认的是private。

5、C++数据类型
在C++中多了一种布尔型（bool）变量

6、引用类型
在C++很重要的一点就是增加了引用类型，主要用于扩充函数传递数据功能
1.指针有自己的一块空间，而引用只是一个别名；
2.使用sizeof看一个指针的大小是4，而引用则是被引用对象的大小；
3.指针可以被初始化为NULL，而引用必须被初始化且必须是一个已有对象
的引用，即不存在空引用，引用必须连接到一块合法的内存。
4.作为参数传递时，指针需要被解引用才可以对对象进行操作，而直接对引
用的修改都会改变引用所指向的对象；
5.可以有const指针，但是没有const引用；
6.一旦引用被初始化为一个对象，就不能被指向到另一个对象。指针可以在任何时候指向到另一个对象。
7.指针可以有多级指针（**p），而引用至于一级；
8.指针和引用使用++运算符的意义不一样；
9.引用必须在创建时被初始化。指针可以在任何时间被初始化。

那么c++为什么要提出引用：
我们在用指针的使用经常犯得错是什么：
1、操作空指针
2、操作野指针
3、不知不觉改变了指针的值，而后还以为该指针正常

而引用的提出就是解决这个问题：
引用区别于指针的特性是：
1、不存在空引用（保证不操作空指针）
2、必须初始化（保证不是野指针）
3、一个引用永远指向他初始化的那个对象（保证指针值不变）

还有很多细微的不同，这里只是列举了主要的，也没有涉及到面向对象的知识