C++ 学习

C++ 基本语法

C++ 是面向对象的语言，因此我们应该设计自己的类的结构，使得类与自己的数据相匹配。

头文件 +宏定义+ 命名空间

#include<iostream> // c++ 中头文件不带.h后缀，但是可以使用 c中的 .h文件

#define ZERO 0 // 宏定义

using namespace std;// 该指令如果在main()中，那么只会在主程序中有效；如果是在程序开头，那么整个程序有效。
/* 
C++中存在命名空间，对于标准的函数，类等模块是存在于 std 标准空间中的， 再使用时应为 std::cin ,
std::cout，为了方便起见使用, using namespace std 可以避免命名空间，直接使用cout, cin 。 
但是当我们需要将多个人写的程序合在一起时，可能会存在 变量相同的情况， 
using namespace Bob, using namespace LiHua 可以将不同人写的程序分开。 
此时就最好不要使用 using namespace std 避免相撞。
*/
using std::cin;
using std::cout; 
// 这样子引用，也可以在该文件中不使用std命名空间，但可以直接使用标准库函数

变量类型

变量需要先声明之后才能使用（当然可以在声明的同时，对变量进行赋值。）
基本类型：整数型，浮点型，数组，指针，结构，字符串
我们在定义基本类型时，我们实际上是开辟了对应的空间，然后将变量名和内存的地址对应起来，然后赋值的时候在内存地址内存储数据。

// 整数类型
int ;
short;
long;
long long;
sizeof(variable) // 可以得到变量占据的字节数 

#include <climits> 
//该头文件有定义很多的 变量的常用信息

//字符类型
char n='n' ;   单字符 

//浮点数类型
float ;
double ;
long double ; 
// 布尔类型
bool judge;

//常量 const
const int Months = 12; 
/*
const 在声明时就需要进行赋值，不然之后就无法再进行赋值。
对于常量，我们可以使用宏定义，也可以使用const。但是const更好！！
因为 const在定义时说明了 变量类型； 同时const的作用域更加的明确；另外const能够用于更加复杂的数据类型中：structure, class中
*/

// 数组： 在定义数组时 需要定义数组的类型，数组名 和 数组的元素数 [动态数组可以改变数组的大小]
int month[12];
int cost[3] ={1, 2, 3}; 
int cost[3] ={1, 2}; // 部分初始化，其他的会设置为0
int cost[] ={1, 2, 3, 4, 5} // 将根据初始化的元素数量 计算数组的大小

// 字符串： 连续存储字符的数组，最后会默认添加'\0'作为结尾， '\0'将作为字符串结尾的标志
char name[] = "John Snow, the king in the north";  \\ 默认添加'\0'，'\0'也计入数组的元素个数中
/* warning： 字符串是双引号" ";  字符是 单引号' '  */
/// 字符串常量的拼接：
char words = "I'm Daenerys Stormborn of the House Targaryen, the Unburnt and Mother of Dragon."
char words = "I'm Daenerys Stormborn of the House Targaryen,"  
"the Unburnt and Mother of Dragon."   
// 空格，制表符和换行符分割的两个字符串常量 可以拼接在一起， 第一个字符串末尾的'\0'会自动被第二个字符串的第一个字符取代

#include<cstring>  
strlen(words);   // 求字符的长度， 将不计入'\0'字符
strcpy(charr1, charr2); //  将charr2赋值给charr1
strcat(charr1,charr2); //将charr2 连接在 charr1之后

#include<string>  // 将提供 string类，能够更方便的对字符串进行操作。
string title; // 将实例化一个字符串类，但是还没有对其进行赋值。 我们在赋值时，c++将自动调整字符串的长度。
string title1="king in the north,"
string title2="warden in the north."
title = title1 + title2; //string 类支持字符串相加 实现合并
int len_title = title.size();

// 结构体： 可以外部声明（main之外声明，可以用于所有的函数中）； 内部声明（main之内声明，只能用于main函数中）
structure employee
{
	std::string name;
	int age;
	double salary;
};

employee jack_ma = 
{
	"Jack Ma",
	50,
	1e20
};  // 初始化

employee faculty[20]; // 将创建一个结构体的数组

// 共用体
union id
{
	long id_num;
	char id_char[20];
} id_val; 
//  共用体中的不同成员之间都是共用同一个地址，因此只能存储其中的一个信息；可以节省内存中的空间

// 枚举

指针

//指针
// 指针： 存储变量的地址，而非变量的内容

///  获取变量的地址 
int a = 10;
&a  // 将获取变量a的存储地址
int * a_adr = &a;  // 创建了一个指针，指针指向的区域时int类型的， 将变量a的地址赋给了指针a_adr 
int *a_adr, *b_adr ; // 创建多个指针时，我们需要每一个前边都是用一个 * ，不然
int *a, b ; // b将是int 变量，而不是指针。
/// 变量在编译时就已经分配好了空间，对于运行时想要分配的内存，只能通过指针来进行操作

int *pt[3] ;  //  将创建 元素为指针的数组

int *pi = new int;
typeName * pointer_name = new typeName; 
/// 我们在创建好指针之后，如果不将之前创建的不用的指针内存进行释放，那么可用的空间就会越用越少
/// 因此 我们需要将不用的指针进行删除（我们实际上删除的不是指针， 而是指针对应的内存。）
/// 我们根据new生成的内存空间，只能通过指针来进行访问，没办法通过变量等形式进行访问，如果我们将该指针指向别的地方，该内存空间将无法访问，也就无法进行删除delete操作。
delete pi;

/// 指针的算数运算：
int tacos[3] = {1,2,3};
int *pt = &tacos[0];
int *pe = &tacos[2];
int len = pe-pt; //可以 对指向同一个数组的两个指针进行相减运算 

///
//new 产生 动态数组，该数组在运行时才会动态分配空间（动态联编）， 而对于 int name[10] 生成的静态联编，将在编译时就生成对应的空间 
// 
int * pt = new int[10];   
pt[1]; // 将访问 第二个元素
*(pt+i); //将访问 i+1个元素
// 数组名 int name[10]  虽然是指针，但是是不可改变的常量。 另外sizeof(name)将是整个数组的字节长度
// 对于 指向数组的指针是可以进行 自加减操作的，而且 sizeof(pt)将是一个指针的长度

// 数组的delete 必须加上 [] ,但是 非数组的删除 不可以加上 [] 
delete [] pt；


// 使用new 创建 动态结构体  
struct things{
	int good;
	int bad;
};
things * grubnose = new things;
// 对于使用 指针的指向的结构体，必须使用 -> 对其成员进行访问  || 或者 使用 (*grubnose).good
*grubnose = {300, 5};
grubnose->good ;

//模板类 vector , array   
*************************待补充***********************
#include<vector>
#include<array>

vector<int> vi; 
array<int,5> ai; 
array<int,4> ad;

逻辑控制语句

//  逻辑控制语句 

循环语句
for (int i=0 ; i<5 ; i++)
{	
	cout<< i <<endl; 
}
 基于范围的for 循环
double prices[5] = {4.99,10.99,6.87,7.99,8.49};
for (double x : prices)    // x 将依次为数组中的元素 
{

}

while ( i<10)
{


}
do 
{

} while( i<10);   // 先执行一次内容，然后再进行条件判断 

 条件判断语句 
1.
if () {

}
else {

}
2.
if (){

}
else if (){

}
else
{

}
2. 
3. && 
4. ||
5. expression1 ? expression2 : expression3 ;
5>3 ? 5 : 3  ; // 如果expression1 正确，那么该表达式的值是 expression2； 如果不正确，那么表达式的值是expression3
6. break;  continue;

函数

函数在使用之前必须提供函数原型。在提供函数原型后，程序中就会识别函数名。函数在程序最后进行定义就可以。当然我们也可以选择在程序的开始将函数直接编写，像python一样

//函数原型
double function(double x);

类

常用函数

//输入输出函数
cout << "Hello World!";
// endl    是cout的结束控制符，能起到换行的作用，等同于 \n
cout<< "hello world!"<<endl; //将能够换行，上一个指令不会换行

int variable = 25;
cout << variable; 
// cout可以将整数直接转换为字符串，然后输出。 这是因为cout实际是 
// 这是因为cout实际上是一个类的对象（实例），能够根据输入的对象不同，实现不同的处理。（运算符重载）

cin >> variables; // cin会根据variables的类型 将输入的类型转化为需要的类型
// cin 输入字符串时，默认以空格或者回车作为一个字符串的结束，因此 普通的cin在输入多个单词后，这些单词都将分别作为一次cin的输入，而不是整体作为一次cin的输入

cin.getline(name.20);  //此时将可以实现多个单词的同时写入，20限定了字符串的最大长度。 将在遇见回车符 或者 字符串长度达到最大（包含'\0'）时结束。getline将丢弃 遇到的换行符。
cin.get(name,20) ；// 与cin.getline 的区别在于 get函数不丢弃 结尾的换行符，将其保留在队列中
cin.get();  // 将读取下一个字符，可以和get(name,20)配合使用