C++21天学会

最新推荐文章于 2023-06-04 11:02:15 发布
最新推荐文章于 2023-06-04 11:02:15 发布
阅读量236 收藏
点赞数
文章标签： c/c++
原文链接：http://www.cnblogs.com/moonlord/p/6991442.html
版权

21天学会C++

标签（空格分隔）： c语言

第一章 C++程序组成部分

一. Hello World程序的组成部分

  1. C++中的helli-world

    #include <iostream>
int main(){
    std::cout << ”HELLO WORLD“ << std::endl;
}
  2. 预处理器编译指令#include：
    预处理器是编译前运行的工具，#include<filename>让处理器获取指定文件的内容，并将这些代码放在编译指令所处的位置
  3. 返回值：
    很多情况下，一个应用程序被另一个程序启动，而父应用程序想知道子应用程序是否成功完成了任务，程序员可通过使用main的返回值向父应用程序传递成功或错误状态

  4. 名称空间：
    （1）代码中使用std::out而不是cout，原因在于cout位于标准名称空间中(std)。假设调用cout时没有使用空间限定符，且编译器知道cout位于两个地方，那编译器应该调用哪个呢，这显然会让编译器混乱。
    （2）代码中频繁添加std限定符很繁琐，为避免添加限定符，可以使用声明using namespace

    using namespace std;
cout << "hello world" << endl

    （3）using不只可以用于限定命名空间这么大的范围，还可以限定到使用的元素
    c using std::cout； using std::endl； cout << "hello world" << endl;

二. 使用typedef替换变量类型

  1. typedef关键字
    （1）C++允许将变量类型替换为您认为方便的名称
    （2）格式为： typedef origionType desType

    typedef unsigned int STRICTLY_OSITIVE_INTEGER
STRICTLY_OSITIVE_INTEGER postNumber = 4532

三. C风格字符串与C++风格字符串

  1. C风格字符串
    （1）C风格的字符串用字符数组来声明，而数组都是需要提前计算好元素个数。
    （2）字符数组的元素个事应该为字符串中字符个数+1，因为编译器会在双引号引起的内容后面加上\0

    char HELLOWORLD2[] = {'h','e','l','l','o','w','o','r','l','d','\0'};

  2. C++风格字符串
    （1）C风格字符串带来的威胁：C语言程序中的strcpy,strcat,strlen等函数，都会寻找终止空字符，如果程序员没有在字符数组末尾添加空字符，这些函数将产生字符数组越界。
    （2）C++提供std::string，这是一种强大而安全的字符串操作方式，他能动态扩展存储大小。

    #include <iostream>
int main(){
    std::string HELLOWORLD2 = "hello world";
    std::cout << HELLOWORLD2 << std::endl;
}

第二章 指针和引用

C++程序可以在字节和比特级调整应用程序的性能，要编写高质量的程序利用系统资源，理解指针和引用就必不可少。

一. 指针

  1. 声明指针
    （1）指针通常声明为指向特定类型，如int，表示指针所示的内存单元存储了一个整数
    （2）也可让指针声明为指向一个内存块，这种指针被称为void指针
    （3）只声明指针，而不去初始化指针，是给指针赋予了一个垃圾值。因为指针包含的值被视为地址，所以未初始化的指针会导致程序访问非法内存，进而导致程序崩溃

    int *pInteger = NULL;

  2. &符号获取变量地址
    所有变量都在内存的一个地址上，可以通过&varialbe来获取变量所处地址。

    #include <iostream>
int main(){
    int Age = 30;
    int* addr = &Age;
    std::cout << "Integer is at: 0x" << std::hex << &Age << std::endl; // Integer is at: 0x0x7fff1422250c
    std::cout << "Addr is: 0x" << std::hex << addr << std::endl;       // Addr is: 0x0x7fff1422250c

}

  3. 使用解除引用运算符*访问指针指向的数据

    int Age = 30;
int* addr = &Age;
cout << dec << *addr << endl;

二. 动态内存分配

  1. new动态分配内存，delete动态释放内存
    （1）使用new来分配新的内存块，需要指定为哪种数据类型分配内存
    （2）语法：TypeName* p = new TypeName，delete p
    （3）分配连续内存：TypeName* p = new TypeName[length]，delete[] p
    ```c
    using namespace std;
    int main(){
    cout << "Enter your name:";
    string name;
    cin >> name;

     int charAllocate = name.length() + 1;   // 字符串结尾的\0
 char* copyName = new char[charAllocate];

 strcpy(copyName,name.c_str());          // 将字符串转换为c类型字符串再拷贝给字符数组
 cout << "Alloacated buffer contains：" << copyName << endl;
 delete[] copyName;

    }
    /**
    Enter your name:lj
    Alloacated buffer contains：lj
    */
    ```

  2. const关键字用于指针的三种形式
    （1）const TypeName* p：当前指针变量指向的内存地址上的数据为常量，不可修改。但指针指向的地址可以改变。
    c int Age=30; const int* p = &Age; //*p = 40; // 编译报错，这样已经改变了指针所指向内存的数据 int num2 = 35; p = &num2; // 改变指针指向的地址可以，编译通过 cout << dec << *p;
    （2）TypeName* const p：指针指向的地址为常量，不可修改，但可修改指向地址上的数据值
    c int Age=30; int* const p = &Age; *p = 40; // 改变地址上的值，编译通过 //int num2 = 35; //p = &num2; // 改变指针指向的地址，编译不通过 cout << dec << *p;
    （3）const TypeName* const p：指针包含的地址，和改地址指向的值都不能修改
    c int Age=30; const int* const p = &Age; // *p = 40; // 不能改变地址上的值 //int num2 = 35; //p = &num2; // 不能改变指针指向的地址 cout << dec << *p;

  3. 当指针变量拷贝到另一个指针变量时，只需对其中一个指针进行delete，多次delete会导致程序崩溃
    c int* p = new int; *p = 30; int* p1 = p; delete p; delete p1; // 程序崩溃

  4. 检查new发出的请求分配是否得到满足
    （1）默认情况下，C++在请求分配内存失败的情况下，抛出std::bad_alloc异常
    c try{ int* p = new int[9999999999]; delete[] p; } catch(bad_alloc){ cout << "Bad allocation" << endl; }
    （2）使用new(nothrow)在内存分配失败的情况下返回NULL
    c int* p = new(nothrow) int[9999999999]; if(p) delete[] p; else cout << "allocate fail"<<endl;

三. 引用

  1. 引用是什么
    （1）引用是一个变量的别名，应用初始化时，应让它指向一个变量
    （2）语法格式
    TypeName original = value
    TypeName& ref = original
    ```c
    int original = 30;
    cout << hex << &original<<endl; // 0x7ffd02a9593c

    int& ref = original; //引用变量的值是内存上的数据值
    cout << hex << &ref << endl; // 0x7ffd02a9593c，引用和original变量的地址相同
    ```

  2. 引用的用处
    （1）因为C++函数的参数传递是值拷贝，当参数所占内存很大时，值复制会消耗大量时间。可以把函数的形参设为引用变量，这样在值传递时，引用指向实参地址，不会发生内存拷贝。
    ```c
    using namespace std;

    void square(int& number){
    number = number * number;
    }

    int main(){
    int number = 10;
    cin >> number; // 输入5

     square(number);
 cout << number <<endl;  // 25
    }
    ```

  3. const用于引用
    （1）const TypeName& ref = origion：禁止通过引用修改原先变量的值
    （2）把函数形参设置为const引用，既可以避免内存拷贝，又可以避免实参得治在函数体中被修改
    ```c
    int square(const int& number){
    // number = number * number; 编译错误，禁止通过引用修改变量值
    return number*number;
    }

    int main(){
    int number = 10;
    cin >> number;

     int result = square(number);
 cout << result <<endl;

    }

    ```

第三章 类

一. 造函数与析构函数

  1. 构造函数与setter,getter
    （1）构造方法写在public代码块内
    （2）Person::name：表示在Person类中生命的name属性。::符号又被称为作用域解析运算符
    ```c
    using namespace std;

    class Person{
    private:
    string name;
    int age;
    public:
    Person(int age,string name){ // 写在public内的构造函数
    this->name = name;
    this->age = age;
    }

     const string &getName() const {  // setter与getter
     return name;
 }

 void setName(const string &name) {
     Person::name = name;
 }

 int getAge() const {
     return age;
 }

 void setAge(int age) {
     Person::age = age;
 }
 void introduceInfo(){  // 表示在Person类中生命的name属性。::符号又被称为作用域解析运算符
     cout << "My name is："<< Person::name << " , age is："<< Person::age << endl;
 }
    };
    int main(){
    Person* p = new Person(23, "zhangsan");
    p->introduceInfo();
    }
    ```

  2. 构造函数的简写形式
    （1）使用Person(int gae,string name):name(name),age(age){}的空函数体形式
    ```c
    class Person{
    private:
    string name;
    int age;
    public:
    Person(int gae,string name):name(name),age(age){} // 构造函数简写形式

     void introduceInfo(){
     cout << "My name is："<<Person::name<<" , age is："<<Person::age << endl;
 }
    };
    int main(){
    Person* p = new Person(23, "zhangsan"); // new返回开辟的内存空间地址起始
    p->introduceInfo();
    }
    ```

  3. 析构函数
    （1）析构函数调用时机：当对象不再在作用域内或被delete删除时，对象被销毁，进而调用析构函数
    （2）析构函数不能重载，每个类只有一个析构函数，如果没有自定义析构函数，编译器会自动加上一个空的析构函数，这样的话，类中动态申请的内存将无法被释放
    ```c
    class MyString{
    private:
    char* buffer;
    public:
    MyString(const char* input){
    if (input!= NULL){
    this->buffer = new char[strlen(input)+1];
    strcpy(buffer,input); // 拷贝input到buffer
    }else{
    buffer = NULL;
    }
    }

     ~MyString(){
     cout<< "mystring clearn up!" <<endl;
     delete[] this->buffer;
 }

    };

    int main(){
    MyString* ms = new MyString("helloworld");
    delete ms; // 对象被销毁，自动调用析构函数
    }
    ```

二. 对象的深浅复制

  1. 对象浅复制
    （1）当一个对象作为函数参数进行传递时，C++的值拷贝只是对象的浅拷贝：只复制其指针成员，不复制指针指向的缓冲区。使得在方法退出时，对象被delete同时也把包含的指针成员指向的缓冲区delete了。当手动delete原函数时，原先的缓冲区已经被delete。会出现错误。
    （2）这种错误一般在ms visual stdio模式下会报错

  2. 复制构造函数
    （1）当程序员手动增加了复制构造函数后，编译器在函数调用时，会使用复制构造函数来创建对象，进行对象值传递。
    （2）形式：
    c class ClassName{ public: ClassName(const ClassName& origion){ ... } }

  3. 移动构造函数
    （1）因为C++严格按照复制构造函数进行参数传递，在对象的指针成员指向的缓冲区很大时，深复制会造成效率降低
    （2）所以在提供复制构造函数的同时，需要提供移动构造函数。形式如下：
    c ClassName(ClassName&& src)

  4. 构造函数举例
    ```c
    class MyString{
    private:
    char* buffer;
    public:
    // 构造函数
    MyString(const char* input){
    if (input!= NULL){
    this->buffer = new char[strlen(input)+1];
    strcpy(buffer,input); // 拷贝input到buffer
    }else{
    buffer = NULL;
    }
    }

     // 复制构造函数
 MyString(const MyString& origion){
     cout << "copy constructor runing.." << endl;
     if(origion.buffer != NULL){
         buffer = new char[strlen(origion.buffer) + 1];
         strcpy(buffer,origion.buffer);
         cout << "buffer points to:0x" << hex << (unsigned int*)buffer << endl;
     }
     else
         buffer = NULL;
 }

 // 移动构造函数
 MyString(MyString&& origion){
     cout << "move constructor running" << endl;
     if(origion.buffer != NULL){
         buffer = origion.buffer;   // 移动后的对象指向原先的缓冲区
         origion.buffer = NULL;     // 对象已移动，原先指针废弃
     }
 }

 char* getbuffer(){
     return buffer;
 }

    };

    void useMyString(MyString input){ //此时参数传递自调用复制构造函数进行对象生成
    cout << "input is" << endl;
    }

    int main(){
    MyString ms("hello world");
    useMyString(ms);
    }
    /**
    copy constructor runing..
    buffer points to:0x0xe78050
    input is
    */
    ```

三. 构造函数与析构函数的其它用途

  1. 单例类
    ```c
    using namespace std;

    class President{
    private:
    President(){}; // 私有化所有造方法
    President(const President&); // 私有化复制构造方法
    const President& operator = (const President&);
    string name;

    public:
    static President& instant(){ // 暴露一个static的返回引用的方法
    static President onlyInstance; // 初始化一个静态对象
    return onlyInstance;
    }
    string getName(){
    return name;
    }
    void setName(string inputName){
    name = inputName;
    }
    };

    int main(){
    President& onlyInstance = President::instant();
    onlyInstance.setName("lj");
    cout << "President's name：" << onlyInstance.getName() << endl; // President's name：lj
    cout << "President's name：" << President::instant().getName() << endl; // President's name：lj
    }
    ```

  2. 不允许在栈中创建的类
    （1）方法中没有用new产生的类就会在栈里面，要想不让栈中产生类，需要私有化析构函数。
    （2）私有化析构函数后，在函数退出时，不能调用析构方法来销毁对象，所以这样的代码就不能通过编译。
    ```c
    class MonsterDB{
    private:
    ~MonsterDB(); // 私有化析构函数
    };

    int main(){
    MonsterDB myDB; // 编译报错，方法中不能再使用类名创建对象
    return 0;
    }
    ```

  3. this指针
    表示当前对象的内存地址

  4. C++中结构体与类
    （1）关键字struct来自于C语言，在C++编译器看来，它与类相似，差别仅在于struct中的属性默认全部是public的，除非显式指定，否则struct以公有类方式继承。
    （2）代码示例
    ```c
    struct Human{
    // 构造函数
    Human(const string& inputname,int inputage):name(inputname),age(inputage){};
    private:
    int age;
    string name;
    };

    int main(){
    Human fistMan("lj",26);
    }
    ```

第四章 模板

一. 使用#define定义宏函数

  1. 宏函数定义
    （1）宏函数通常用于非常简单的计算
    （2）宏不考虑数据类型，因此使用宏函数编程很危险

    using namespace std;
#define MAX(a,b) (a>b?a:b)
int main(){
    cout << MAX(3,8) << endl;  // 8
}

  2. 使用assert宏函数验证表达式
    （1）引入assert函数先导入assert.h文件
    c #include <assert.h> int main(){ char* sayHello = new char[25]; // sayHello不是空，报错：int main(): Assertion `sayHello == NULL' failed. assert(sayHello == NULL); delete[] sayHello; }

  3. 宏函数的优缺点：
    （1）优点：宏函数将在编译前就地展开，因此简单宏的性能优于函数调用。因为它避免了创建函数栈，传递参数等高开销cpu
    （2）缺点：宏函数不支持任何形式的类型检查。

二. 模板

  1. 模板声明
    （1）模板让程序员可以定义一种适用于不同类型对象的行为
    （2）模板方法声明：

    template <tyoename T1,typename T2>     // template参数声明
bool fun1(const T1& p1,const T2& p2);

    （3）模板类声明：
    c template <typename T1,typename T2> // template参数声明 class Test{ private: T1 obj1; T2 obj2; public: T1 getObj1(){ return obj1; } };

  2. 模板举例
    （1）模板函数
    c using namespace std; // 模板函数 template <typename T> const T& getMax(const T& v1,const T& v2){ if (v1 > v2) return v1; else return v2; } int main(){ int v1 = 25; int v2 = 35; int max = getMax(v1,v2); // 模板函数调用编译器可自行推断参数类型 int max2 = getMax<int>(v1,v2); // 模板函数调用也可自行指定参数类型 cout << max2 << endl; }
    （2）模板类
    ```c
    template
    class Person{
    private:
    T1 name;
    T2 age;
    public:
    Person(const T1& name,const T2& age){
    this->name = name;
    this->age = age;
    }
    const T1& getName() const{
    return name;
    }
    const T2& getAge() const{
    return age;
    }
    };

    int main(){
    Person <char*,int> p ("zhangsan",23); // 具体化模板类可以手动指定类型
    cout << p.getName() << endl;
    cout << p.getAge() << endl;

     Person <> p1 ("lj",26);  // 由于模板参数中给出了默认类型，所以p1的具体化可以使用空类型
 cout << p1.getName() << endl;
 cout << p1.getAge() << endl;

    ```

转载于:https://www.cnblogs.com/moonlord/p/6991442.html

weixin_30374009
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++21点小游戏课程设计
10-19
C++21点小游戏课程设计：21点小游戏，顾名思义，玩家需要通过纸牌上的点数，通过继续拿牌和不要牌，来增长自己的点数，当最接近21点，或者等于21时，胜利；但当玩家的点数超过21点时，即游戏失败。利用面向对象程序设计方法以及C++的编程思想来完成设计；
用十年来学编程
magictong的专栏
04-01 1829
英文原作者：Peter NorvigTeach Yourself Programming in Ten Years 中文翻译转载之：http://coolshell.cn/?p=2250 为什么每个人都急不可耐？走进任何一家书店，你会看见《Teach Yourself Java in 7 Days》（7天Java无师自通）的旁边是一长排看不到尽头的类似书籍，它们要教会你Vi
21天学会C++：Day1----C++的发展史
m0_73096566的博客
04-14 775
21天学会C++：Day1
21天教你学会C++
Deep Thinking
12-19 518
下面是一个《Teach Yourself  C++ in 21 Days》的流程图，请各位程序员同仁认真领会。如果有必要，你可以查看这个图书以作参照：http://www.china-pub.com/27043看完上面这个图片，我在想，我学习C++有12年了，好像C++也没有学得特别懂，看到STL和泛型，还是很头大。不过，我应该去考虑研究量子物理和生物化学，这样，我才能重返98年杀掉还在大学的我，然
“21天教你学会C++”，不要太在意~
stone15165的博客
05-09 2377
下面是一个《Teach Yourself  C++ in 21 Days》的流程图，请各位程序员同仁认真领会。如果有必要，你可以查看这个图书以作参照：http://www.china-pub.com/27043看完上面这个图片，我在想，我学习C++有6年了，好像C++也没有学得特别懂，看到STL和泛型，还是很头大。不过，我应该去考虑研究量子物理和生物化学，这样，我才能重返08年杀掉还在大学的我，然...
21天学会C++中文
10-29
21天学会C++中文
21天学会C++
05-13
21天学会C++21天学会C++21天学会C++21天学会C++21天学会C++21天学会C++21天学会C++21天学会C++21天学会C++21天学会C++
21天学会C++ 第四版
12-02
21天学会C++ 第四版21天学会C++ 第四版
21天学会C++：Day7----auto关键字
m0_73096566的博客
06-04 645
21天学会C++：Day7----auto关键字
《21天学通 C++》学习总结
skroute的博客
03-29 236
类和对象 1、class默认私有，struct默认公有 2、学会构造初始化的类 3、new需要析构函数delete 4、深复制（引用） 5、公有下的聚合初始化 6、sizeof（）在各种情况下显示的大小 继承 1、通过使用关键字 protected，可对需要继承的基类属性进行保护，禁止在继承层次结构外部访问它 2、何在 main 中，使用作用域解析运算符（::）通过派生类 的实例调用基类方法 ...
21点游戏C++程序及代码可用
07-04
21点经典纸牌游戏，C++实现，适合课程设计，源码进过测试绝对可用
21天学通C++第七版完整版PDF下载
09-24
21天学通C++第七版完整版PDF下载，这个pdf有170多兆，是完整版的，500页左右，我只能上传60M以下的文件，所以给的是百度网盘地址及密码，永久有效
21天学通C++(第7版)源代码
01-24
21天学通C++(第7版)源代码 有需要的敬请下载
21天学通C++（第6版）205
04-29
内容比较清晰，适合新手学习的资料。讲解比较基础的语法。C++学习资料。
C++基础入门21 精讲
05-20
若其他学科编程语言的学习步骤是：学习，应用、上项目，那么C/C++语言的学习步骤为：学习、理解、应用、上项目，多了一步理解。就是“理解”之步骤彰显了C/C++学习难度大于其他编程语言。 本课程十分适用与学员自学
C++ 笔记 21 （STL常用算法 - 遍历 & 查找）
pangyushuang的博客
05-02 736
功能：查找指定元素，找到返回指定元素的迭代器，找不到返回结束迭代器end()。总结：find_if按条件查找使查找更加灵活，提供的仿函数可以改变不同的策略。总结：利用find可以在容器中找到指定的元素，返回值是迭代器。总结：二分查找法效率很高，但是查找的容器中元素必须是有序序列。总结：for_each是最常用的遍历算法，需要熟练掌握。总结：搬运的目标容器必须提前开辟空间，否则无法正常搬运。功能：查找指定元素是否存在。功能：按条件统计元素个数。功能：查找相邻重复元素。功能：按条件查找元素。
C++21——运算符重载
m0_47887988的博客
03-30 1570
只能对已经有的符号进行重载，不能凭空创造符号进行重载 只能对类或者枚举类型进行重载 符号操作数个数不能改变（如：+有两个操作数，1+1），优先级不能改变 实例 const String String::operator+(const String& that);//作为成员函数 const String operator+(const String& r,const String& l);//作为全局函数 class Integer{...
c++ - 第21节 - 智能指针
qq_45113223的博客
01-09 1065
为什么需要智能指针。
C++ 新特性
weixin_39318565的博客
09-20 420
C++新特性
21天学通c++ 第8版 视频
最新发布
10-23
《21天学通C语言》第8版视频是为帮助学习C语言的初学者而制作的教学视频，旨在通过21天的学习计划，帮助学生快速入门C语言编程。 该视频分为多个章节，每个章节以简明易懂的语言和示例代码向学生介绍C语言的基础...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值