C++的初步学习

c是面向过程的语言，c++是面向对象的语言，
面向过程的程序设计主要是：数据结构加算法。面向对象的程序设计主要现实世界建立软件模型。
c++的标准：C++ 98 标准
C++标准第一版，1998年发布。正式名称为ISO/IEC 14882:1998[17] 。
C++ 03 标准
C++标准第二版，2003年发布。正式名称为ISO/IEC 14882:2003[18] 。
C++ 11 标准
C++标准第三版，2011年8月12日发布。正式名称为ISO/IEC 14882:2011[19] 。
C++11对容器类的方法做了三项主要修改。
首先，新增的右值引用使得能够给容器提供移动语义。其次，由于新增了模板类initilizer_list，因此新增了将initilizer_list作为参数的构造函数和赋值运算符。第三，新增的可变参数模板（variadic template）和函数参数包（parameter pack）使得可以提供就地创建（emplacement）方法。

C++ 14 标准
C++标准第四版，2014年8月18日发布。正式名称为ISO/IEC 14882:2014[21] 。
C++14是C++11的增量更新，主要是支持普通函数的返回类型推演，泛型 lambda，扩展的 lambda 捕获，对 constexpr 函数限制的修订，constexpr变量模板化等[22] 。

命名空间： **namespace 是C++中的关键字，用来定义一个命名空间，**语法格式为：
namespace name
{
变量
函数
类
}
namespace的使用： ::是一个新符号，称为域解析操作符，在C++中用来指明要使用的命名空间。
NameSpaceA::a = 10; // 使用命名空间 NameSpaceA中的变量a
NameSpaceB::a = 20; // 使用命名空间 NameSpaceB中的变量a
对整个空间的命名要用到using； using 声明不仅可以针对命名空间中的变量或者函数，还可以对整个命名空间进行声明。一般用 using namespace std；来命名整个空间。
头文件: iostream.h：用于控制台输入输出头文件。
C++ 引入了命名空间的概念，计划重新编写库，将类、函数、宏等都统一纳入一个命名空间，这个命名空间的名字就是std。std 是 standard 的缩写，意思是“标准命名空间”。 具有C库功能的新C++头文件具有如 cstdio、cstdlib 这样的名字。它们提供的内容和相应的旧的C头文件相同，只是内容在 std 中。
c++的关键字：register：register关键字请求“编译器”将局部变量存储于寄存器中
C语言中无法取得register变量地址 C++编译器发现程序中需要取register变量的地址时，register对变量的声明变得无效
struct：struct Student
{
char name[20];
int age;
};

int main()
{
// C语言中 struct 定义了一组数据的集合，而不是一种新的数据类型
// 所以在定义变量的时候需要在前面加上 struct 关键字进行修饰
// C++中 struct 定义了一种新的数据类型，可以直接用来定义变量
Student stu1 = {“xiaoming”, 10};

return 0;

}
struct test //C语言，结构体只是各种数据类型的集合， C++中，结构体是一种类型
{

};
c++的一些不好使用的方式：f() // **C语言中，函数如果没有返回值，void可以省略
{
printf(“heloworld!\n”);
}
void f2() //表示能接受任意参数
{
}
void f3(void) //表示函数没有参数
{

}**
bool类型是新增的关键字。
C++中的布尔类型
C++在C语言的基本类型系统之上增加了bool
C++中的bool可取的值只有true和false
理论上bool只占用一个字节，
如果多个bool变量定义在一起，可能会各占一个bit，这取决于编译器的实现

  true代表真值，编译器内部用1来表示
  false代表非真值，编译器内部用0来表示

  bool类型只有true（非0）和false（0）两个值
  C++编译器会在赋值时将非0值转换为true，0值转换为false    

三目运算符：
int main()
{
int a = 10;
int b = 20;

// **C++中三目运算符返回的是变量本身，所以可以作为左值使用**
(a > b ? a : b) = 90;

// **在C语言中让三目运算符可以当左值使用，可以通过返回变量地址实现**
*(a > b ? &a : &b) = 90;
printf ("%d, %d\n", a, b);

return 0;

}

const的使用：
int main()
{
const int a = 1; //常量，不占用内存 存放在符号表中
int *p = (int *)&a; //如果进行取地址操作，编译器会分配4个字节内存，并且用1来填充

*p = 10;
cout << a << endl;

return 0;

}
#endif

void f()
{
const int a = 100; //常量
#define b 200 //常量 作用于不一样，a 作用域 函数内部 b 作用域，从这一行开始
}

int main()
{
f();
//cout << a << endl;
cout << b << endl;
return 0;
}

// C++中 const 变量声明的是一个真正的常量，不是变量，所以编译器不会为该常量分配空间
// const 修饰的常量会被放到 符号表 中
const int a = 10;

// 这里对 const 常量取地址，这一步操作会让编译器为该变量分配空间，分配的空间并不会被 a 使用
int *p = (int *)&a;

// 通过指针改变指向的空间的值，这个空间是编译器为常量分配的空间，但是常量的值并不在这个空间内
// 所以即使通过指针修改了这个空间的值，也不会影响到 a 本身
*p = 5;

// a 的值不变，因为它的值在符号表中，不在程序运行的空间内
printf ("%d, %p\n", a, *p);

return 0;

c++的引用：
/ 定义一个int型变量a,在内存中占4个字节，
// 变量名 a 就代表了这一块内存，或者说 a 是这块内存的别名
int a = 10;

// 定义了一个引用变量 b ，它是 a 的别名，和 a 代表同一块内存空间
// 对 b 的操作 和 对 a 的操作是一样的
int& b = a;

// 改变 b 等于改变了 a
b = 20;

printf ("%d, %d\n", a, b);

// a 与 b 代表同一块内存空间
printf ("%p, %p\n", &a, &b);

return 0;

奇怪的语法现象;
struct test
{
double &a;
char &b; //当成指针来分析
};

int main()
{
int a = 1;
char b = ‘z’;

int &c= a;
char &d = b;

char str[32] = {0};        //str++;  常指针

cout << sizeof(c) << endl;
cout << sizeof(d) << endl;  //不用关心编译器是怎么处理的（正常的语法现象）

cout << sizeof(test) << endl; //当分析奇怪的语法现象，需要考虑引用的具体实现 (常指针)

return 0;

}
结果是4,1,8 。4是a占4个字节的空间，1是z这字符占一个字节， 8是指针类型占8个字节的，这里char加取地址，当做指针处理，所以占8个字节。一般来说，char占一个字节。

常引用：
int main()
{
int a = 1;
int &b = a; //普通引用 变量初始化普通引用

//int &c = 100;  //不能用常量初始化普通引用

const int &d = a;   //用变量初始化常引用
//d++;     //常引用不能修改
a++;
cout << d << endl;

const int &e = 10;  //用常量初始化常引用，编译分配四个字节内存，并且用10填充
//e++;

return 0;

}
int main()
{
int a = 10;
int &b = a; // 普通引用

int x = 20;
const int& y = x;   // 常引用  让变量y拥有只读属性，不能通过y改变x的值

// 常引用 初始化 分为 2中情况
// 1、用变量初始化 常引用
{
    int a1 = 20;
    const int& b1 = a1; // a1 变量去初始化常引用
}
// 2、用常量去初始化常引用
{
    const int a  = 40; // C++编译器把a放在符号表中

    // int& b = 41;    // 普通引用，引用一个常量，常量是没有地址空间的，这样的做法是不合法的

    // 使用常量去初始化常引用是合法的,C++编译器会为该引用分配空间，常量的值存储到分配的空间中去
    // 使用常量对 const引用 初始化后，将生成一个只读变量
    const int& b = 42;

    int *p = (int *)&b;
    *p = 50;

    printf ("%d\n", b);
}
**当使用常量（字面量）对const引用进行初始化时，C++编译器会为常量值分配空间，并将引用名作为这段空间的别名**

默认参数及使用规则:
只有参数列表后面部分的参数才可以提供默认参数值
一旦在一个函数调用中开始使用默认参数值，那么这个参数后的所有参数都必须使用默认参数
void f(int a, int b = 100, int c = 200) //一旦开始使用默认参数，那么这个参数后面的所有参数都得使用默认参数
{
cout << a << " " << b << " " << c << endl;
}

int main()
{
f(1, 2);

return 0;

}
占位参数：可以与默认参数结合使用
void f(int x, int y, int = 0) //占位参数和默认参数结合使用
{
cout << x << " " << y << endl;
}

int main()
{
f(1, 2);

return 0;

}
函数重载：
重载函数在本质上是相互独立的不同函数（静态链编）
重载函数的函数类型是不同的
函数返回值不能作为函数重载的依据
函数重载是由函数名和参数列表决定的。
 
int func(int a, int b, int c=0)
{
    return a + b;
}
 
int func(int a, int b)
{
    return a + b;
}
 
int main()
{
    func(1,2); // 哪个函数会被调用
 
    return 0;
}