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 %dn", 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，思路比较杂乱，还有比较深层次的东西，由于自己也是刚入门不久的小白，就不献丑了，
哪里有错和需要商榷的，欢迎补充。