1.C++基本语法、注释、数据类型、变量作用域、常量
对象 - 对象具有状态和行为。例如：一只狗的状态 - 颜色、名称、品种，行为 - 摇动、叫唤、吃。对象是类的实例。
类 - 类可以定义为描述对象行为/状态的模板/蓝图。
方法 - 从基本上说，一个方法表示一种行为。一个类可以包含多个方法。可以在方法中写入逻辑、操作数据以及执行所有的动作。
即时变量 - 每个对象都有其独特的即时变量。对象的状态是由这些即时变量的值创建的。
c++标识符：用来标识变量、函数、类、模块，或任何其他用户自定义项目的名称。一个标识符以字母 A-Z 或 a-z 或下划线 _ 开始，后跟零个或多个字母、下划线和数字（0-9）。
C++标识符内不允许出现标点字符，比如 @、& 和 %。C++ 是区分大小写的编程语言。
c++注释：单行和多行
/* 这是注释 */
/* C++ 注释也可以
* 跨行
* /
C++七种基本数据类型：bool(true false)、char、int、float、double、void、wchar_t(宽字符)
一些基本类型可以使用一个或多个类型修饰符进行修饰：signed、unsigned、short、long
typedef声明：使用 typedef 为一个已有的类型取一个新的名字：typedef type newname；
枚举类型：由用户定义的若干枚举常量的集合。
enum 枚举名{
标识符[=整型常数],
标识符[=整型常数],
标识符[=整型常数],
标识符[=整型常数],
}枚举变量;
变量是程序可操作的存储区的名称。C++ 中每个变量都有指定的类型，类型决定了变量存储的大小和布局，该范围内的值都可以存储在内存中，运算符可应用于变量上。
变量定义与初始化：type variable_name = value； int d = 3;
作用域是程序的一个区域，一般来说有三个地方可以定义变量：
在函数或一个代码块内部声明的变量，称为局部变量。
在函数参数的定义中声明的变量，称为形式参数。
在所有函数外部声明的变量，称为全局变量。
常量是固定值，在程序执行期间不会改变。这些固定的值，又叫做字面量。
定义常量：1.使用#define预处理器 2.使用const关键字
#include <iostream>
using namespace std;
#define LENGTH 10 //定义常量
//枚举
enum times{
first,
second,
third
}tm;
int g = 20;//全局变量
int main(int argc, const char * argv[]) {
int a = 10;//局部变量
std::cout << "Hello, World!\n";
cout << a <<"\n";
const int WIDTH = 5;//定义常量
int area = LENGTH * WIDTH;
cout << area <<"\n";
tm = first;
switch (tm) {
case first:
cout<<"first\n";
break;
case second:
cout<<"second\n";
break;
case third:
cout<<"third\n";
break;
default:
break;
}
return 0;
}
81.png
2.c++存储类
C++存储类：
存储类定义 C++ 程序中变量/函数的范围（可见性）和生命周期。这些说明符放置在它们所修饰的类型之前。
包括：auto、register、static、extern、mutable、thread_local(C++11)
auto 关键字用于两种情况：声明变量时根据初始化表达式自动推断该变量的类型、声明函数时函数返回值的占位符。
auto f = 3.14; //double
auto z = new auto(9); //int*
auto s("hello"); //const char*
register存储类用于定义存储在寄存器中而不是 RAM 中的局部变量。
static:指示编译器在程序的生命周期内保持局部变量的存在，而不需要在每次它进入和离开作用域时进行创建和销毁。因此，使用 static 修饰局部变量可以在函数调用之间保持局部变量的值。
static 修饰符也可以应用于全局变量。当 static 修饰全局变量时，会使变量的作用域限制在声明它的文件内。
extern:用于提供一个全局变量的引用，全局变量对所有的程序文件都是可见的。
mutable 说明符仅适用于类的对象.
thread_local 说明符声明的变量仅可在它在其上创建的线程上访问。 变量在创建线程时创建，并在销毁线程时销毁。 每个线程都有其自己的变量副本。
#include <iostream>
// 函数声明
void func(void);
static int count = 5; //静态全局变量
int main(int argc, const char * argv[]) {
while(count--)
{
func();
}
return 0;
}
// 函数定义
void func( void )
{
static int i = 5; // 局部静态变量
i++;
std::cout << "变量 i 为 " << i ;
std::cout << " , 变量 count 为 " << count << std::endl;
}
82.png
3.运算符
C++运算符
算术运算符：+、-、*、/、%、++、--。加、减、乘、除、取模、自增、自减。
关系运算符：==、!=、>、<、>=、<=。相等、不相等、大于、小于、大于等于、小于等于
逻辑运算符：&&、||、！ 逻辑与、逻辑或、逻辑非
位运算符：&、|、^、~、<<、>>、 与、或、异或、翻转位、左移、右移
赋值运算符：=、+=、-=、*=、/=、%=、<<=、>>=、&=、^=、|=
杂项运算符：
sizeof运算符返回变量的大小。
Condition ? X : Y 条件运算符，如果 Condition 为真 ? 则值为 X : 否则值为 Y。
.（点）：成员运算符用于引用类、结构和共用体的成员。
&：指针运算符 & 返回变量的地址。
*：指针运算符 * 指向一个变量。
4.循环和判断
C++循环
循环类型：
while循环
for循环
do…while循环
循环控制语句：
break：终止 loop 或 switch 语句，程序流将继续执行紧接着 loop 或 switch 的下一条语句。
continue：引起循环跳过主体的剩余部分，立即重新开始测试条件。
C++判读
判断语句：
if语句
if…else语句
switch语句
？：运算符：
exp1 ？ exp2 ： exp3；
5.函数
/*
C++函数
函数是一组一起执行一个任务的语句。每个 C++ 程序都至少有一个函数，即主函数 main()。
定义函数：
return_type function_name(parameter list){
body
}
返回类型
函数名称
参数
函数主体
函数参数：
如果函数要使用参数，则必须声明接受参数值的变量。这些变量称为函数的形式参数。
形式参数就像函数内的其他局部变量，在进入函数时被创建，退出函数时被销毁。
当调用函数时，有两种向函数传递参数的方式：
传值调用:该方法把参数的实际值复制给函数的形式参数。在这种情况下，修改函数内的形式参数对实际参数没有影响。
指针调用：该方法把参数的地址复制给形式参数。在函数内，该地址用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数。
引用调用：该方法把参数的引用复制给形式参数。在函数内，该引用用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数。
*/
#include <iostream>
int sum(int a, int b){
int result;
result = a + b;
return result;
}
int main(int argc, const char * argv[]) {
int a = 1;
int b = 2;
int result = sum(a, b);
std::cout<<"total value is:"<<result;
return 0;
}
6.数组
/*
C++数组
它可以存储一个固定大小的相同类型元素的顺序集合。
声明数组：type arrayName [arraySize];
*/
#include <iostream>
using namespace std;
int main(int argc, const char * argv[]) {
int n[10] = {1,2,3,4,5,6,7,8,9,10};//声明并初始化数组
int sum = 0;
for(int i = 0; i<10;i++){
sum = sum + n[i];
}
cout<<"sum = "<<sum<<"\n";
return 0;
}
7.字符串
/*
C++字符串
c风格字符串
C++引入的string类类型
字符转函数：
strcpy(s1, s2);复制字符串 s2 到字符串 s1。
strcat(s1, s2);连接字符串 s2 到字符串 s1 的末尾。
strlen(s1);返回字符串 s1 的长度。
strcmp(s1, s2);如果 s1 和 s2 是相同的，则返回 0；如果 s1<s2 则返回小于 0；如果 s1>s2 则返回大于 0。
strchr(s1, ch);返回一个指针，指向字符串 s1 中字符 ch 的第一次出现的位置。
strstr(s1, s2);返回一个指针，指向字符串 s1 中字符串 s2 的第一次出现的位置。
*/
#include <iostream>
using namespace std;
int main(int argc, const char * argv[]) {
char str1[11] = "Hello";
char str2[11] = "World";
char str3[11];
long len ;
// 复制 str1 到 str3
strcpy( str3, str1);
cout << "strcpy( str3, str1) : " << str3 << endl;
// 连接 str1 和 str2
strcat( str1, str2);
cout << "strcat( str1, str2): " << str1 << endl;
// 连接后，str1 的总长度
len = strlen(str1);
cout << "strlen(str1) : " << len << endl;
//c++中的string类
string s1 = "hello";
string s2 = "world";
string s3;
long leng;
s3 = s1;
cout<<"s3:"<<s3<<endl;
s3 = s1 + s2;
cout<<"s1+s2:"<<s3<<endl;
leng = s3.size();
cout<<"s3.size():"<<leng<<endl;
return 0;
}
83.png
8.指针
/*
C++指针
type *var-name;
指针是一个变量，其值为另一个变量的地址，即，内存位置的直接地址。
所有指针的值的实际数据类型，都是一样的，都是一个代表内存地址的长的十六进制数。
不同数据类型的指针之间唯一的不同是，指针所指向的变量或常量的数据类型不同。
int *ip; 一个整型的指针
double *dp; 一个 double 型的指针
float *fp; 一个浮点型的指针
char *ch; 一个字符型的指针
*/
#include <iostream>
using namespace std;
int main(int argc, const char * argv[]) {
int var = 20; // 实际变量的声明
int *ip; // 指针变量的声明
ip = &var; // 在指针变量中存储 var 的地址
cout << "Value of var variable: ";
cout << var << endl;
// 输出在指针变量中存储的地址
cout << "Address stored in ip variable: ";
cout << ip << endl;
// 访问指针中地址的值
cout << "Value of *ip variable: ";
cout << *ip << endl;
return 0;
}
84.png
9.引用
/*
C++引用
引用变量是一个别名，也就是说，它是某个已存在变量的另一个名字。一旦把引用初始化为某个变量，就可以使用该引用名称或变量名称来指向变量。
C++ 引用 vs 指针：
不存在空引用。引用必须连接到一块合法的内存。
一旦引用被初始化为一个对象，就不能被指向到另一个对象。指针可以在任何时候指向到另一个对象。
引用必须在创建时被初始化。指针可以在任何时间被初始化。
引用通常用于函数参数列表和函数返回值。
*/
#include <iostream>
using namespace std;
double vals[] = {10.1, 12.6, 33.1, 24.1, 50.0};
double& setValues( int i )
{
return vals[i]; // 返回第 i 个元素的引用
}
// 函数定义
void swap(int& x, int& y)
{
int temp;
temp = x; /* 保存地址 x 的值 */
x = y; /* 把 y 赋值给 x */
y = temp; /* 把 x 赋值给 y */
return;
}
int main(int argc, const char * argv[]) {
// 声明简单的变量
int i;
double d;
// 声明引用变量
int& r = i;
double& s = d;
i = 5;
cout << "Value of i : " << i << endl;
cout << "Value of i reference : " << r << endl;
d = 11.7;
cout << "Value of d : " << d << endl;
cout << "Value of d reference : " << s << endl;
//把引用用作参数
// 局部变量声明
int a = 100;
int b = 200;
cout << "交换前，a 的值：" << a << endl;
cout << "交换前，b 的值：" << b << endl;
/* 调用函数来交换值 */
swap(a, b);
cout << "交换后，a 的值：" << a << endl;
cout << "交换后，b 的值：" << b << endl;
//把引用作为返回值
setValues(1) = 20.23; // 改变第 2 个元素
setValues(3) = 70.8; // 改变第 4 个元素
cout << "改变后的值" << endl;
for ( int i = 0; i < 5; i++ )
{
cout << "vals[" << i << "] = ";
cout << vals[i] << endl;
}
return 0;
}
Snip20171013_85.png
10.结构体
/*
C++ 数据结构
结构是 C++ 中另一种用户自定义的可用的数据类型，它允许您存储不同类型的数据项。
定义结构：
struct type_name {
member_type1 member_name1;
member_type2 member_name2;
member_type3 member_name3;
.
.
} object_names;
*/
#include <iostream>
using namespace std;
// 声明一个结构体类型 Books
struct Books
{
char title[50];
char author[50];
char subject[100];
int book_id;
};
//方式二：
/*
typedef struct
{
char title[50];
char author[50];
char subject[100];
int book_id;
}Books;
*/
//结构作为函数参数
void printBook( struct Books book )
{
cout << "书标题 : " << book.title <<endl;
cout << "书作者 : " << book.author <<endl;
cout << "书类目 : " << book.subject <<endl;
cout << "书 ID : " << book.book_id <<endl;
}
int main(int argc, const char * argv[]) {
Books Book1; // 定义结构体类型 Books 的变量 Book1
Books Book2; // 定义结构体类型 Books 的变量 Book2
// Book1 详述
strcpy( Book1.title, "C++ 教程");
strcpy( Book1.author, "Runoob");
strcpy( Book1.subject, "编程语言");
Book1.book_id = 12345;
// Book2 详述
strcpy( Book2.title, "CSS 教程");
strcpy( Book2.author, "Runoob");
strcpy( Book2.subject, "前端技术");
Book2.book_id = 12346;
// 输出 Book1 信息
cout << "第一本书标题 : " << Book1.title <<endl;
cout << "第一本书作者 : " << Book1.author <<endl;
cout << "第一本书类目 : " << Book1.subject <<endl;
cout << "第一本书 ID : " << Book1.book_id <<endl;
// 输出 Book2 信息
printBook( Book2 );
return 0;
}
Snip20171013_86.png
