C++自学笔记

C++学习笔记
#ifndef COMPLEX
#define COMPLEX

写头文件防卫式声明

#endif

写一个类时：1数据在private里 2参数和返回值尽量用reference来传 3加const

#define identifier value ex: #define LENGTH 10

const type variable = value; ex: const int LENGTH = 10;

const 相比 #define 的优点：

1.const 常量有数据类型，而 #define 没有，编译器可以对前者进行类型安全检查，而对后者只能进行字符替换，没有安全检查，并且在字符替换时候可能导致意想不到的错误。

2.有些集成化的调试工具可以对 const 常量进行调试，但是不能对宏常量进行调试。

enum 枚举名{
标识符[=整型常数],
标识符[=整型常数],
… ex: enum color { red, green, blue } c;
c = blue;
标识符[=整型常数]
} 枚举变量;

在C++中，有一种特殊的成员函数，它的名字和类名相同，没有返回值，不需要用户显式调用（用户也不能调用），
而是在创建对象时自动执行。这种特殊的成员函数就是构造函数（Constructor）

存储类定义 C++ 程序中变量/函数的范围（可见性）和生命周期。这些说明符放置在它们所修饰的类型之前。
ex：extern 存储类-extern 是用来在另一个文件中声明一个全局变量或函数

向函数传递参数的传值调用方法，把参数的实际值复制给函数的形式参数。在这种情况下，修改函数内的形式参数不会影响实际参数。
#include
using namespace std;

// 函数声明
void swap(int x, int y);

int main ()
{
// 局部变量声明
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;

return 0;
}

运行后发现ab的值没有进行交换，因为每个值有俩个变量俩个名称 x,y,a,b

向函数传递参数的指针调用方法，把参数的地址复制给形式参数。在函数内，该地址用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数。
void swap(int *x, int *y)
{
int temp;
temp = x; / 保存地址 x 的值 */
*x = y; / 把 y 赋值给 x */
y = temp; / 把 x 赋值给 y */

Return
swap(&a, &b);

向函数传递参数的引用调用方法，把引用的地址复制给形式参数。在函数内，该引用用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数。
void swap(int &x, int &y)
{
int temp;
temp = x; /* 保存地址 x 的值 /
x = y; / 把 y 赋值给 x /
y = temp; / 把 x 赋值给 y */

return;
}
swap(a, b);

第二张图用了引用

Lambda 函数与表达式

Lambda函数的语法定义如下：

capture mutable ->return-type{statement}
其中：

[capture]：捕捉列表。捕捉列表总是出现在 lambda 表达式的开始处。事实上，[] 是 lambda 引出符。编译器根据该引出符判断接下来的代码是否是 lambda 函数。捕捉列表能够捕捉上下文中的变量供 lambda 函数使用。
(parameters)：参数列表。与普通函数的参数列表一致。如果不需要参数传递，则可以连同括号 () 一起省略。
mutable：mutable 修饰符。默认情况下，lambda 函数总是一个 const 函数，mutable 可以取消其常量性。在使用该修饰符时，参数列表不可省略（即使参数为空）。
->return_type：返回类型。用追踪返回类型形式声明函数的返回类型。出于方便，不需要返回值的时候也可以连同符号 -> 一起省略。此外，在返回类型明确的情况下，也可以省略该部分，让编译器对返回类型进行推导。
{statement}：函数体。内容与普通函数一样，不过除了可以使用参数之外，还可以使用所有捕获的变量。
在 lambda 函数的定义式中，参数列表和返回类型都是可选部分，而捕捉列表和函数体都可能为空，C++ 中最简单的 lambda 函数只需要声明为：

[]{};
ex：[](int x, int y) -> int { int z = x + y; return z + x; }

在C++中，setw(int n)用来控制输出间隔,（n-1个空格）。

C++中函数是不能直接返回一个数组的，但是数组其实就是指针，所以可以让函数返回指针来实现:

short int height[10]; //int型的数组（short int 每个数据2字节）
cout << "height "<< height << endl
<< "height+1 "<< height + 1 << endl
<< "&height[0] " << &height[0] << endl
<< "&height+1 "<< &height + 1<< endl
<< "height+9 "<< height+9 << endl
<< "height+10 " << height + 10 << endl;

结果如下:

height 0136F900
height+1 0136F902
&height[0] 0136F900
&height+1 0136F914
height+9 0136F912
height+10 0136F914
可以看到：

height 与 &height[0] 值相等。
height+1 = height + 2 字节 = height + 1 个 short int 也即 一个数组元素。
height+9 为 height[] 中最后一个元素的地址，height+10 为该数组结束后的第一个地址。
&height +1=height+10，即执行 &height+1 的结果是地址跳到整个数组之后第一个地址。

int var[MAX] = {10, 100, 200};
int *ptr;

// 指针中的数组地址
ptr = var; //和 ptr=&var[0]; 一样

输出数组for+ptr++；

指针数组
int var[MAX] = {10, 100, 200};
int *ptr[MAX];
ptr[i] = &var[i]; // 赋值为整数的地址

字符串数组
const char *names[MAX] = {
“Zara Ali”,
“Hina Ali”,
“Nuha Ali”,
“Sara Ali”,
};

int&;
这里的&不是取地址符号，而是引用符号，引用是C++对C的一个重要补充。
同样可以理解如果变量b是变量a的引用 那么无论a，b中任何一个值改变，另外一个也相应的改变，在声明一个引用时，必须同时使之初始化，即声明它代表哪一个变量。

C++ 标准库没有提供所谓的日期类型。C++ 继承了 C 语言用于日期和时间操作的结构和函数。为了使用日期和时间相关的函数和结构，需要在 C++ 程序中引用 头文件。

箭头（->）：左边必须为指针；
点号（.）：左边必须为实体。
struct Books
{
char title[50];
}
strcpy( Book1.title, “C++ 教程”);

// 该函数以结构指针作为参数
void printBook( struct Books *book )
{
cout << "书标题 : " << book->title <<endl;
}

类与结构体在 C++ 中只有两点区别，除此这外无任何区别。

（1）class 中默认的成员访问权限是 private 的，而 struct 中则是 public 的。
（2）从 class 继承默认是 private 继承，而从 struct 继承默认是 public 继承。
（3）class 可以定义模板，而 struct 不可以。

成员函数在类的内部定义
class Box
{
public:
double getVolume(void)
{
return length * breadth * height;
}
};

也可以在外部定义但是要加：：:: 叫作用域区分符，指明一个函数属于哪个类或一个数据属于哪个类。

:: 可以不跟类名，表示全局数据或全局函数（即非成员函数）
double Box::getVolume(void)
{
return length * breadth * height;
}

myBox.getVolume(); // 调用该对象的成员函数

// 不使用成员函数设置宽度
// box.width = 10.0; // Error: 因为 width 是私有的
box.setWidth(10.0); // 使用成员函数设置宽度
cout << "Width of box : " << box.getWidth() <<endl;

protected（受保护）成员变量或函数与私有成员十分相似，但有一点不同，protected（受保护）成员在派生类（即子类）中是可访问的。