初入C++

书写规范

1. 代表类型的名字必须首字母大写，而其他的字母大小写混合
2. 预定义常量必须全部大写，且用下划线分隔单词
3. 在；后换行，新行对齐
4. 永远不要依赖隐式转换
5. 在编程时一般禁用制表符与分页符（在不同的编译环境中所显示的空格不一样）
6. 函数名一般由动宾短语组成，首字母大写
7. 在定义默认参数时应该后置
8. 调用函数时实参前置
9. C++中直接用零代替C中的NULL
10. 类名首字母大写

什么是面向对象编程？

1. 并非面对对象，而是源于对象
2. 万物皆对象，在程序设计中，变量即对象
3. 对象 = data+operations （人）+（可以吃喝拉撒睡）
4. 从问题空间到程序空间的映射
   面向过程：我打开冰箱，取出吃的，然后吃掉，最后关闭冰箱
   面向对象：冰箱可以被打开和关闭，我可以吃东西，冰箱里有吃
   的，无关乎过程怎么实现，只在乎你能干什么
   从源代码角度来讲就是对结构体的扩充
5. 写程序时牢牢记住，不要去深入到蛋黄里面去
6. 一个程序就是一堆对象告诉彼此怎么处理数据（做什么）
7. 每一个对象都有自己的内存空间，且由其他对象组成
8. 所有可以接受相同消息的对象可以认为是同一类（所有的杯子都可以
   装水）
9. 接口化的程序设计，程序各个部分的耦合程度（保护内部对象，通信）
10. 使得程序的开发和维护更加的容易

为什么c++不喜欢宏定义

转自：http://blog.csdn.net/pegasuswang_/article/details/18359911
1. 会被简单的替换，甚至将注释//也替换进去
2. 容易出错
3. 不能指定类型
4. 有更好的实现方式
2. 替代方法，在c++中尽量的使用const就行了，用inline替代一些简单的函数

你好，世界

#include <iostream>

using namespace std;//

int main()
{
    cout << "Hello world!" << endl;
    return 0;
}

1. endl相当于C语言中的换行符

2. using name space的问题，当你同时需要using name space A和B时，便无法
   解决函数同名的问题

基本数据类型（More than c）

bool experssion

#include <iostream>

using namespace std;

int main()
{
    bool isYou;
    isYou = true;
    if(isYou)
    {
        cout<<"isYou="<<isYou<<endl;
        cout<<boolalpha<<"isYou="<<isYou<<endl;
    }
    cout << "Hello world!" << endl;
    return 0;
}

1. 非零值为直接转化为True，0值为false
2. 布尔类型的变量和函数应该使用前缀is，或者用can，has等动词
3. 布尔类型的true在转化为int类型时，会转化0
4. boolAlpha将bool值按照字符串输出

类型转换

1. 需先声明static_castvalue
2. static_cast2,将整型的2强制类型转换为了double类型的

变量初始化

1. int X = 1；
2. int x(1)； c++特有
3. int x；x(1)；error

函数

局部变量的作用域

void function(){
for(int i;i<10;i++)
{
    int sum = 0;
    sum = sum+i;
}
for(int i;i<10;i++)
{
    int sum = 0;
    sum = sum+i;
}
}
void function2(){
int i =1;
for(int i;i<10;i++)
{
    int sum = 0;
    sum = sum+i;
}
cout<<sum<<i;
}

1. 编译时并无冲突，i的作用域就在{ }之间
2. 函数二i的输出值仍然为1；

全局变量的作用域

#include <iostream>

using namespace std;
int v1 = 10;
int main()
{
    int v1 = 5;
    cout<<v1<<endl;
    cout<<::v1;
    return 0;
}

1. 当局部变量名与全局变量名重名时，可使用：：来访问全局变量

重载函数

#include <iostream>

using namespace std;
double getMin(int  x, double y)
{
    if(x>y)
        return y;
        else
            return x;

}
double  getMin(double  x, int  y)
{
    if(x>y)
        return y;
        else
            return x;

}
int main()
{
    int x=1,y=2;
    double min;
    min = getMin(x,y);

    cout << min << endl;
    return 0;
}

1. 重载函数，即仅当函数参数无法匹配实参的时候，编译器会生成一个同名而不同参的
   函数
2. 编译器按照参数的个数，类型，顺序来匹配重载函数调用
3. 在上述程序中，编译器无法确定正确的项时即导致编译错误

默认参数值

#include <iostream>

using namespace std;
void printArea(double r = 2);
int main()
{
  printArea();
  printArea(4);
    return 0;
}
void printArea(double r )
{
    cout<<r*3.14*3.14<<endl;
}

int add(int x,int y=10)
{
    return x+y;
}
int add(int x)
{
    return  x+100;
}
int main()
{
 add(1);
  cin.get();
    return 0;
}

1. 当无参数调用时，默认值会被传递给形式参数
2. 默认参数不能被重定义，即使是相同的值（上例double r =2的话程序便会报错）
3. 默认函数使用不当会引起二义重载

内联函数（inline）

1. 由于大量的函数会大量开销计算机的性能（内存的分配，函数堆栈的创建）
2. 使用内联函数会是的程序的体积增大，就像我们初学C语言时，将一个函数到处乱写，用空间换取了时间
3. inline是对编译器的请求，而不是命令，编译器自行决断使不使用，而大多数机器并不会把带有循环，递归，代码较多的函数进行内联编译，因为对大程序来书，函数调用的开销是可以忽略的

引用与动态内存管理

引用

1. 变量的别名通过引用所做的操作实际上是作用于原变量上
2. 可做参数调用，传参时传变量名即可
3. 与指针的差别（比指针简单）
4. 特别的在C++中int& a;这里的&仅仅是用作引用的说明

动态内存管理

#include <iostream>

using namespace std;

int main()
{
    int *p = new int(1);
    int *s = new int[10];
    for(int i=0;i<10;i++)
    {
        s[i] = i;
    }
    cout << p << endl;
    cout<<*p<<endl;
    cout << &p<<endl;
     for(int i=0;i<10;i++)
    {
        cout<<s[i]<<" ";
    }
    cout<<endl;
    for(int i=0;i<10;i++)
    {
        cout<<s+i<<" ";
    }
     cout<<endl;
     for(int i=0;i<10;i++)
    {
        cout<<*s+i<<" ";
    }
    cout<<endl;
         for(int i=0;i<10;i++)
    {
        cout<<*(s+i)<<" " ;
    }
   cout<<endl;
    delete p;
    delete []s;
    return 0;
}

1. c++中通过运算符new来申请动态空间
2. 通过delete来释放内存空间
3. 还是一样需要通过指针来保存
4. 与malloc不同new还会调用类的构造函数，delete也是一样
5. new/delete不需要头文件支持
6. new/delete更符合oo的习惯，不回去直接访问地址
7. new自带类型信息，而malloc返回的是void类型你的指针

类

“`

using namespace std;
class Human
{
public:
int age;
Human()
{
age = 20;
}
Human(int Age)
{
age = Age;
}
void Can()
{
cout<<”我可以吃喝拉撒睡”;
}

};
int main()
{

Human fxg;
Human *pHuman = &fxg;
Human *p2Human = new Human(23);

// Human Fxg = new Human(25);(错误的)
// cout<

构造函数

1. 与类同名，无返回值，课重载，课不带参数
2. 类可不声明构造函数，默认的有

创建对象并访问

1. 访问对象运算符 .
2. public：公有访问
3. 本质上是一种数据类型
4. 成员拷贝，只是单纯的替换参数，而不是合并对象
5. 匿名对象（刚买回来要吃的鸡，你会给它命名吗？），类名（参数），不需要对象名；

将声明和实现分离开

1. ：：域分隔符
2. 当函数在类声明中实现，自动成为内联函数

对象指针和动态对象的创建

1. ->指针访问成员运算符