自 顶向下、逐步求精。

面向对象的方法

   封装、继承、多态

   把对象的属性和操作封装起来，形成一个类；类是一个抽象的概念；class

C语言和C++语言关系

C语言是在实践的过程中逐步完善起来的 C语言的目标是高效

C语言 + 面向对象方法论===》Objective C /C++

每一个程序员都不能固步自封，要多接触新的行业、新的技术领域。暂新的突破自我

在C语言中只有一个全局作用域

在C语言中只有一个全局作用域

std是c++标准命名空间，c++标准程序库中的所有标识符都被定义在std中，比如标准库中的类iostream、vector

可以更好地控制标识符的作用域

1） 当使用<iostream>的时候，该头文件没有定义全局命名空间，必须使用namespace std；这样才能正确使用cout。若不引入using namespace std ,需要这样做。std::cout。

2）     c++标准为了和C区别开，也为了正确使用命名空间，规定头文件不使用后缀.h。

3）     C++命名空间的定义：   namespace name {  …  }

4）     using namespace NameSpaceA;

5）namespce定义可嵌套。

namespace NameSpaceA
{
    int a = 0;
}
 
namespace NameSpaceB
{
    int a = 1;
 
    namespace NameSpaceC
    {
       struct Teacher
       {
           char name[10];
           int age;
       };
    }
}
 
int main()
{
    using namespace   NameSpaceA;
    using   NameSpaceB::NameSpaceC::Teacher;
 
    printf("a = %d\n",   a);
    printf("a = %d\n",   NameSpaceB::a);
 
    Teacher t1 = {"aaa",   3};
 
    printf("t1.name = %s\n",   t1.name);
    printf("t1.age = %d\n",   t1.age);
 
    system("pause");
    return 0;
}

Register

//register关键字 请求编译器让变量a直接放在寄存器里面，速度快

//在c语言中 register修饰的变量 不能取地址，但是在c++里面做了内容

/*

//1

register关键字的变化

register关键字请求“编译器”将局部变量存储于寄存器中

C语言中无法取得register变量地址

在C++中依然支持register关键字

C++编译器有自己的优化方式，不使用register也可能做优化

C++中可以取得register变量的地址

//2

C++编译器发现程序中需要取register变量的地址时，register对变量的声明变得无效。

//3

早期C语言编译器不会对代码进行优化，因此register变量是一个很好的补充。

*/

/*

在C语言中，重复定义多个同名的全局变量是合法的

         在C++中，不允许定义多个同名的全局变量

C语言中多个同名的全局变量最终会被链接到全局数据区的同一个地址空间上

int g_var;

int g_var = 1;

C++直接拒绝这种二义性的做法。

*/

int main(int argc, char *argv[])
{
         printf("g_var   = %d\n", g_var);
         return   0;
}

struct Student
{
      char name[100];
      int age;
};
 
int main(int argc, char *argv[])
{
      Student s1 = {"wang", 1};
      Student s2 = {"wang2", 2};      
      return 0;
}

总结：

/*

在C语言中

         int   f(    )；表示返回值为int，接受任意参数的函数

         int   f(void)；表示返回值为int的无参函数

         在C++中

         int   f(  );和int f(void)具有相同的意义，都表示返回值为int的无参函数

*/

C++更加强调类型，任意的程序元素都必须显示指明类型

int main()
{
         int   a = 10;
         int   b = 20;
 
         //返回一个最小数   并且给最小数赋值成3
         //三目运算符是一个表达式   ，表达式不可能做左值
         (a   < b ? a : b )= 30;
 
         printf("a   = %d, b = %d\n", a, b);
 
         system("pause");
 
         return   0;
}

1）C语言返回变量的值 C++语言是返回变量本事

2）

C语言中的三目运算符返回的是变量值，不能作为左值使用

C++中的三目运算符可直接返回变量本身，因此可以出现在程序的任何地方

注意：

3）

三目运算符可能返回的值中如果有一个是常量值，则不能作为左值使用

(a < b ? 1 : b )= 30;

4）C语言如何支持类似C++的特性那？

变量的本质是内存空间的别名，是一个标号。

默认参数

函数默认参数的规则

         只有参数列表后面部分的参数才可以提供默认参数值

         一旦在一个函数调用中开始使用默认参数值，那么这个参数后的所有参数都必须使用默认参数值

/*

函数占位参数

占位参数只有参数类型声明，而没有参数名声明

一般情况下，在函数体内部无法使用占位参数

*/

默认参数和占位参数

int func(int a, int b, int = 0)
{
         return   a + b;
}
 
int main66(int argc, char *argv[])
{
         printf("func(10,   20) = %d\n", func(10, 20));
 
         printf("Press   enter to continue ...");
         getchar();         
         return   0;
}

//当函数默认参数遇上函数重载会发生什么

/*
int func(int a, int b, int c = 0)
{
         return   a * b * c;
}
 
int func(int a, int b)
{
         return   a + b;
}
 
int main()
{
         int   c = 0;
 
         c   = func(1, 2); // 存在二义性，调用失败，编译不能通过 
 
         printf("c   = %d\n", c);
 
         printf("Press   enter to continue ...");
         getchar();         
         return   0;
}
*/

/*

编译器调用重载函数的准则

         将所有同名函数作为候选者

         尝试寻找可行的候选函数

         精确匹配实参

         通过默认参数能够匹配实参

         通过默认类型转换匹配实参

         匹配失败

         最终寻找到的可行候选函数不唯一，则出现二义性，编译失败。

         无法匹配所有候选者，函数未定义，编译失败。

         */

/*

函数重载的注意事项

         重载函数在本质上是相互独立的不同函数（静态链编）

         重载函数的函数类型是不同的

         函数返回值不能作为函数重载的依据

函数重载是由函数名和参数列表决定的。

*/

//重载和函数指针结合

/*

函数重载与函数指针

         当使用重载函数名对函数指针进行赋值时

         根据重载规则挑选与函数指针参数列表一致的候选者

         严格匹配候选者的函数类型与函数指针的函数类型

*/

/*
int func(int x) // int(int a)
{
         return   x;
}
 
int func(int a, int b)
{
         return   a + b;
}
 
int func(const char* s)
{
         return   strlen(s);
}
 
typedef int(*PFUNC)(int a); // int(int a)
 
int main(int argc, char *argv[])
{
         int   c = 0;
         PFUNC   p = func;
 
         c   = p(1);
 
         printf("c   = %d\n", c);
 
         printf("Press   enter to continue ...");
         getchar();         
         return   0;
}
*/

函数重载与函数指针

         当使用重载函数名对函数指针进行赋值时

         根据重载规则挑选与函数指针参数列表一致的候选者

         严格匹配候选者的函数类型与函数指针的函数类型

结论：

C语言中的const变量

C语言中const变量是只读变量，有自己的存储空间

C++中的const常量

可能分配存储空间,也可能不分配存储空间 

当const常量为全局，并且需要在其它文件中使用

当使用&操作符取const常量的地址

符号表、编译过程中若发现对const使用了extern或者&操作符，则给对应的常量分配存储空间（兼容C）

int main()
{
         const   int a = 10;
         int   *p = (int*)&a; 
         printf("a===>%d\n",   a);
         *p   = 11;
         printf("a===>%d\n",   a);
 
         printf("Hello......\n");
         return   0;
}

C++中的const常量类似于宏定义

const int c = 5; ≈ #define c 5

C++中的const常量在与宏定义不同

const常量是由编译器处理的，提供类型检查和作用域检查

宏定义由预处理器处理，单纯的文本替换

2、  普通引用有自己的空间吗？

struct Teacer {
    int &a;
    int &b;
};
int main()
{
    printf("sizeof(Teacher)   %d\n", sizeof(Teacer));
    system("pause");
    return 0;
}

3、  //当实参传给形参引用的时候，只不过是c++编译器帮我们程序员手工取了一个实参地址，传给了形参引用（常量指针）