effective c++学习心得(一)
effective c++学习心得(一)
条款01
这一部分，主要讲了使用c++进行编程，作者讲c++称为语言联邦，可以有几种形式，简单的来说主要分为:
1.类似c++使用**过程式**进行编程。 2.采用了**面向对象**的思想。 3.用于c++中提供了template这个特性，所以就出现了**泛型编程**。 4.另一个则是归功于STL的强大，它对容器，迭代器，算法，函数对象，各自都能很好的配合，性能也很不错。
条款02
在传统的c++语言中，对于定义常量，一般都是使用define关键字来进行定义的，在编译器源程序时，
预编译器会将代码中出现有关用#define定义的常量和函数全部替换。
缺点：
例如：当我们要进行调试程序时，因为编译器已经将原有的常量的符号用一个数值来替代，这时
进行调试时，我们只能看到数字，却不能看到对应的符号，产生了极大的不便。除此之外，当你
，想对一个const取地址时，对于define定义的常量时取不了地址的，所以const在这里又发挥了作用。
利用define语句我们无法创建一个类专属常量，因为一旦一个宏被定义，他将存在于整个编译单元，
或者更大的作用域范围，他并不重视作用域的概念，不能提供很好的封装性。
所以在c++中我们有更好的解决方案，那就是使用const和enum来定义一个常量和一个枚举型数据。对于一个常量型变量编译器会将变量名称记录进符号表中。
注意：在c语言中定义的const常量可以通过指针来改变，但是c++中是不可行，
c++中不提倡改变常量的值，但是也有方法改变。
#include <stdio.h>
int main(){
int a = 1;
const int p = a;
int *ptr = &p;
*ptr = 2;
printf("the p is %d\n", p);
}关于const的介绍
一.使用const定义变量
int a = 1; const int *p = &a; //const在*前面，代表指针解引用后的值不可改变 int * const p = &a; // const在* 后面表示指针指向的地址不可改变 const int * const p = &a; // 而这种情况则表示指针指向的地址和解引用的值不可改变
二.在类中使用const关键字
1.常成员变量
class A{
public:
A():a(1){} //const声明的成员变量，必须使用初始化列表，来进行初始化
// const变量不可更改
void get();
private:
const int a;
};2.常成员函数
常成员函数可以区分函数重载，定义和实现常成员函数都要加const
常成员函数中，不能更新成员变量，不能调用非常成员函数。
2.常成员函数实现
public:
A(int i, int j):a(i), b(j){}
void get() const;
private:
const int a;
int b;
};
void A::get() const {
b = 2; //错误，不能更新成员变量
cout << "the b+1 is " << b+1 << endl; // 这种只是打印数据，不算更新
}3.常成员函数区分函数重载
#include <iostream>
using namespace std;
class A{
public:
A(int i, int j):a(i), b(j){}
void get() const;
void get();
private:
const int a;
int b;
};
void A::get() const {
cout << "this is a class " << endl;
}
void A::get(){
cout << "this is a const class " << endl;
}
int main(){
const A a(1,2); // 常对象，调用get()的常成员函数版本
A a1(1,2); // 一般对象，调用普通成员函数
a.get();
a1.get();
return 0;
}enum
简单介绍一下enum的使用方法：
enum {ONE, TWO}; //直接可以使用ONE，TWO的值
enum W{ONE,TWO}a, b; //通过enum关键字声明a，b两个enum类型的值
a = ONE, b=TWO; //赋值操作
typedef enum W{ONE, TWO}w; //使用typedef为enum W 起了个别名w
w w1 = ONE; //使用w为w1赋值，相当于 enum W w1 = ONE；
w w2 = TWO;
typedef enum {ONE, TWO}w; //可以省略点W
w w1 = ONE;
w w2 = TWO;首先我们先看一下static修饰符的作用:
在类我们使用的是静态变量
#include <iostream>
class Widget{
public:
Widget(){}
private:
const static int i; // 这种是正确的
const static int i = 1; //这种是错误的
// 静态类成员变量也称类变量，他不属于单个对象，而是被所有对象共享，
//只初始化一次，并且在程序运行期间，内存中只有一份拷贝。还有一点要
//特别注意的是，类变量只能在类中声明，在类外定义。
};
const int Widget::i = 1; // 类外声明类变量
int main(){
Widget w;
return 0;
}这时就引发了一个问题，如果我要在类被实例化成一个对象之间，调用静态常量，由于没有初始化，并没有自己想要的
初值，所以引发了一些不必要的麻烦，此时可以借助enum的帮助
#include <iostream>
class Widget{
public:
Widget(){}
void get(){ // 在类中直接实现了函数，编译器会考虑将它变成内联函数。
std::cout << "the ONE is " << ONE << std::endl;
}
private:
enum {ONE = 2}; //定义了一个枚举类型的变量，在类成员函数中可以使用这个常量值
};int main(){
Widget w;
return 0;
}只是简单介绍了enum的作用，他的功能还有很多，如果想要了解更多，可以自行百度enum。
简单粗略地介绍了条款1 和2，思路比较杂乱，还有比较深层次的东西，由于自己也是刚入门不久的小白，就不献丑了，
哪里有错和需要商榷的，欢迎补充。