Cpp基础

最新推荐文章于 2024-05-17 14:24:48 发布
最新推荐文章于 2024-05-17 14:24:48 发布
阅读量250 收藏 1
点赞数
分类专栏： c++ 文章标签： cpp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34502729/article/details/77732586
版权

C++ 引入命名空间

#include<iostream>
//引入整个命名空间 
//using namespace std;
//引入部分命名空间
//using std::cout;
//using std::endl; 

int main(){
    //用到时引入 
    std::cout << "hhh" << std::endl;
    return 0;
}

C++ bool类型

int main(){
    bool a = true;
    a = false;
    cout << a + 1 << endl;
    //结果输出 1
    //c++ 中bool变量 true为 1 false为 0
    return 0;
}

const关键字

int main(){
    //const 使变量变为只读 read-only 
    int a = 10;
    const int *p = &a;//使p指向的地址内容为只读 
    int const *q = &a;// 与上面相同 
    int * const r = &a;// 使r的指向为只读 

    *r = 20;

    cout << "a = " << a << endl;

    return 0;
}

c++ 字符串

#include<iostream>
#include<string>
#include<cstring> //在c++中使用c的库 

using std::cout;
using std::endl; 
using std::cin;
using std::string;

int main(){
    //c中使用字符串 
    char str[10] = "world";
    char *a = str;
    strcat(a, "123"); //c中拼接字符串 
    cout << a << endl; 
    //c++中使用字符串 
    string s = "hello";
    //将c风格的字符串赋值给c++中的字符串对象 
    s = a; 
    s += "456"; //c++中拼接字符串 
    const char *p = s.c_str(); //将c++中的字符串对象转换成char指针 
    cout << s << endl;
    cout << p << endl;

    return 0;
}

c++ 引用

//使用引用，进行函数传值 
void fun(int &ref){
    ref = 300;
}
int main(){
    int a = 10;
    int b = 90;
    int &ref = a;//声明引用，代表 ref为 a的一个别名 , ref 和 a 同时代表了申请的那段空间 
    //引用关系不能更改 
//  int &ref = b; 

    ref = 30; 
    fun(ref); 
    cout << a << endl;

    return 0;
}

c++ new 和 delete

struct Student{
    char *name;
    int id;
    int age;
};

int main(){
    struct Student s;
    //c中申请堆区内存
    struct Student *p = (struct Student *)malloc(sizeof(struct Student));

    s.name = "hello";
    p -> id = 1001;
    cout<< s.name <<endl;
    free(p);
    p = NULL;
    //c++中申请堆区内存
    struct Student *q = new Student();

    q -> name = "world"; 
    cout<< q -> name <<endl;
    delete q;
    return 0;
}

c++ 异常机制

int mydiv(int a, int b){
    if (b == 0){
        throw b;
    } else {
        return a / b;
    }
}

int main(){
    int a = 10, b = 5;
    b = 2;
    try{
        int res = mydiv(a, b);

        cout<< "res = " << res <<endl;
    } catch(int b){
        cout<< "b = " << b <<endl;
    } catch(...){
        cout<< "other error happened" <<endl;
    }


    return 0;
}

c++ vector容器

#include<iostream>
#include<vector>

using namespace std;

int main(){
    vector<char> vec_char(0);//定义一个空的vector容器 “(0)”也可以不写

    vec_char.push_back('a');//往容器的最后添加数据 
    vec_char.push_back('b');
    vec_char.push_back('b');
    cout << (vec_char.empty() ? "empty" : "not empty") << endl;

    for (int i = 0; i < vec_char.size(); i++){
        cout << vec_char.at(i) << endl;// 也可以使用 vec_char[i] ，使用at方法可以检测下标越界 
    } 

    return 0;
}

c++ list容器

#include<iostream>
#include<list>

using namespace std;

int main(){
    list<int> lt_int;
    lt_int.push_back(10);//在尾部插入数据 
    lt_int.push_back(11);
    lt_int.push_front(20);//在头部插入数据 
    lt_int.push_front(19);

    list<int>::iterator int_iterator; //声明一个迭代器，指明类型
    //使用迭代器插入元素 
    int pos = 2;
    int_iterator = lt_int.begin();
    while(pos-- > 0){
        int_iterator++;
    } 
    lt_int.insert(int_iterator, 30);

    lt_int.sort();//元素从小到大排序 
    lt_int.reverse();//逆置 

//  int_iterator = lt_int.begin();//返回list中第一个元素的iterator，end()返回最后一个元素后一个位置    
    //类似于指针的使用 
    for (int_iterator = lt_int.begin(); int_iterator != lt_int.end(); int_iterator++){
        cout<< *int_iterator <<endl;
    } 

    return 0;
}

c++ map容器

#include<iostream>
#include<map>
#include<string> 

using namespace std; 

int main(){
    map<string, string> map_string;//声明一个空的map容器，key为string，value为string
    map_string["a"] = "cpp";
    map_string["b"] = "c";

    cout<< "key: a | value: " << map_string["a"] <<endl;

    return 0;
}

c++ 声明一个类

#include<iostream>
#include<string>

using namespace std;

class Person{
    public:
        string name;

        string getHobby(){
            return this -> hobby;   
        }
        void setHobby(string hobby){
            this -> hobby = hobby;
        }
        int getAge(){
            return this -> age; 
        }
        void setAge(int age){
            this -> age = age;
        }
        void displayInfo();//声明成员函数 

    protected:
        int age;
    private:
         string hobby;
};
//在类的外部实现类的成员函数 
void Person::displayInfo(){
    cout<< this -> name << " : " << this -> age << " : " << this -> hobby <<endl;
}

int main(){
    Person a; //在栈中声明一个Person类的引用变量 
    a.name = "Tom";
    a.setAge(20);
    a.setHobby("Football");
    a.displayInfo();

    Person *p = new Person();//在堆区创建Person类的一个对象 ，并返回该对象在堆区的首地址 
    p -> name = "Jack";
    p -> setAge(15);
    p -> setHobby("Basketball");
    p -> displayInfo(); 

    delete(p);
    p = NULL;

    return 0;
}

c++ 构造函数和析构函数

#include<iostream>
#include<string>

using namespace std;

class Person{
    public:
        string name;

        Person(){
            cout<< "无参构造函数被调用" <<endl; 
        }
        Person(string name, int age, string hobby){
            cout<< "有参构造函数被调用" <<endl; 
            this -> name = name;
            this -> age = age;
            this -> hobby = hobby;
        }
        ~Person(){
            cout<< "析构函数被调用" <<endl;
        }

        string getHobby(){
            return this -> hobby;   
        }
        void setHobby(string hobby){
            this -> hobby = hobby;
        }
        int getAge(){
            return this -> age; 
        }
        void setAge(int age){
            this -> age = age;
        }
        void displayInfo(){
            cout<< this -> name << " : " << this -> age << " : " << this -> hobby <<endl;
        }

    protected:
        int age;
    private:
         string hobby;
};

int main(){
    {
        Person p1;//  在栈区创建的对象，变量作用范围结束的时候调用析构函数 
    }

    Person *p2 = new Person("Jack", 15, "Ball"); 
    p2 -> displayInfo();
    delete p2;// 在堆区创建的对象，delete的时候调用析构函数 
    p2 = NULL; 
    return 0;
}

c++ 继承

#include<iostream>

using namespace std;

class Animal{
    public:
        void setName(string name){
            this->name = name;
        }
        void setAge(int age){
            this->age = age;
        }
        void setType(string type){
            this->type = type;
        }
        void display(){
            cout<< name << " : " << age << " : " << type <<endl;
        }
    protected:
        string name;
    private:
        int age;
        string type;
}; 

class Fish: private Animal{
    public:
        void fun(){
            display();
            cout<< name <<endl;
        }
};

class GoldFish: public Fish{
    public:
        void fun2(){
//          display();
        }
};

int main(){
    // 基类中private修饰的成员始终不能被派生类继承
    // 基类中public修饰的成员始终可以被派生类继承，不同的继承方式，会改变成员的访问权限 
    // protected方式会使派生类中public -> protected、protected -> protected 
    // private方式会使派生类中public -> private、protected -> private 

    return 0;
}

c++ 静态成员

#include<iostream>
#include<string>
using namespace std;

class Student{
    public:
        static string id;
        int a;

        static void display(){
            cout<< id <<endl;//静态成员函数可以访问静态成员变量，不可访问非静态成员 
        } 
};

string Student::id;//初始化的时候分配内存 

int main(){
    Student::id = "1001";
    Student::display();
    return 0;
}

c++ 虚函数与纯虚函数

#include<iostream>

using namespace std;

class Person{
    public:
        void eat(){
            cout<< "Person eat" <<endl;
        }
        //声明为虚函数，使用父类的指针或者引用可以访问到子类中对该函数的重写 
        virtual void run(){
            cout<< "Person run" <<endl;
        }
        //声明为纯虚函数 
        virtual void sleep() = 0;
};

class Student: public Person{
    public:
        //重写父类的函数 
        void eat(){
            cout<< "Student eat" <<endl;
        }
        void run(){
            cout<< "Student run" <<endl;
        }
        //子类必须重写父类的纯虚函数 
        void sleep(){
            cout<< "Student sleep" <<endl;
        } 
};

int main(){
    Student s;
    Person *p = &s;

    p -> eat();//在父类中没有声明为虚函数，则只能访问到父类自己的函数 
    s.eat(); 

    p -> run();
    p -> sleep();

    return 0;
}

c++ 多继承与虚继承以及命名空间的声明

#include<iostream>

using namespace std;
//命名空间的声明方式 
namespace Name{ 
    class A{
        public:
            int a;
    };
    //虚继承使子类在实现多继承时，在父类出现冲突时，只会得到父类中冲突成员的一份拷贝 
    class B1: virtual public A{
        public:
            int b1;
    };

    class B2: virtual public A{
        public:
            int b2; 
    };

    class C: public B1, public B2{
        public:
            void fun(){
                int s = a;
            }
    }; 
}
int main(){
    Name::A a;
    a.a = 10;

    return 0;
}
qq_34502729
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
cpp入门基础知识
y_willing的博客
09-26 692
c++入门
Cpp基础版：TC1033
02-16
"Cpp基础版：TC1033"可能是针对C++初学者的一个教程或指南，旨在帮助他们理解和掌握C++的基础概念。 在C++的学习过程中，首先需要了解的是它的语法基础，这包括变量、数据类型、运算符和控制结构。变量是存储数据的...
CPP基础知识
Y_KolaFish_Y的博客
04-25 5439
CPP 基础知识（一） author:dr@g0n 由于一些原因需要用到cpp的知识，所以在此处记录学习，更多更新内容请看yuque（https://www.yuque.com/along-ojern/mob3of/psynut） 此学习小结，更具Cherno的youtube教程总结而来，他的cpp教程简介易懂，十分适合有一定开发编程经验的同学（https://www.youtube.com/watch?v=18c3MTX0PK0&list=PLlrATfBNZ98dudnM48yfGUldqGD0
2、CPP 基础语法学习
vincent3678的博客
05-24 1840
很多语法点从汇编角度分析就很明了了 加油一、基础语法 A1、cin、cout2、函数重载（Overload）3、默认参数4、extern "C"C 和 C++混合开发二、基础语法 B5、内联函数 （inline function）窥探内敛函数的本质：内联函数与宏表达式6、 const7、引用（Reference）引用的本质三、汇编语言1、学习汇编指令的 2 大知识点：2、内联汇编3、汇编指令mov 指令call 指令lea指令（指针）ret、add、sub、inc、dec、xorjmp常见代码的汇编4、.
cpp基础知识
alphacode的博客
03-07 115
c/c++基础知识记录与学习
cpp基础思维导图
qq_56913257的博客
05-17 206
加上之前的类思维导图，基础总结完！
CPP基础学习
嵌入式与人工智能
10-07 562
CPP基础学习C++ 学习网址C引入C++C++ 重载 引用 友元抽象封装继承多态模板（STL）C++11特性智能指针 C++ 学习网址 CPP 学习 https://www.cplusplus.com/reference/ C++入门教程 面向对象思想 C引入C++ C++struct继承struct C++ 重载 引用 友元 函数重载 抽象 C++ 抽象 封装 C++封装 继承 多态 模板（STL） STL简单例子 Stack_STL C++11特性 智能指针 C++ 智能指针 s
编程语言——cpp基础
Zuoerfeng
11-07 1353
cpp的基础主要阅读的是《c++ primer》这本书 以下给出这本书阅读之后的笔记链接： http://note.youdao.com/noteshare?id=9a82d95db165c4b8f7fa140b18ee79b8
CPP入门基础知识
DREAMonce_的博客
06-18 4721
一.CPP和C语言的不同 1. cpp和C语言的头文件不同 C语言的头文件一般用#include<stdio.h>而cpp的头文件为#include<iostream>而在cpp的头文件之后还有 using namespace std; 命名空间使用namespace来声明，std命名空间是C++中标准库类型对象的命名空间，命名空间实际上是一个作用域 2.输入和输出的区别
Cpp/Qtday010906cpp基础
sy311SB的博客
09-06 82
思维导图。
cpp（c++）基础
热门推荐
alun550的博客
12-25 1万+
C++入门必备知识点纪录
CPP.rar_cpp基础作业
09-24
在本压缩包"CPP.rar_cpp基础作业"中，主要包含了C++编程语言的学习资源，特别是一些基础练习项目。这些项目旨在帮助初学者理解和掌握C++的基础知识，以及如何运用这些知识来解决实际问题。下面将对其中涉及的重要...
cpp基础实例2 练习题
08-05
cpp基础实例cpp基础实例cpp基础实例
cpp基础实例 3 练习题
08-05
【cpp基础实例 3 练习题】 在学习C++编程的过程中，基础实例是不可或缺的部分，它们帮助我们理解和掌握各种编程概念。C++是一种强大的、面向对象的编程语言，广泛应用于系统软件、游戏开发、应用软件等领域。在这个...
cpp基础实例1 练习题
08-05
cpp基础实例cpp基础实例cpp基础实例
1111111111111111111111
08-13
1111111111111111
javascript笔试题参考整理(答案)(可编辑修改word版).docx
08-13
javascript笔试题参考整理(答案)(可编辑修改word版)
财务收支表-公式计算查询.xlsx
08-13
工资表，财务报表，对账表，付款申请，财务报告，费用支出表，财务收支 适用人群：学习不同技术领域的小白或进阶学习者；可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
集团信息化顶层规划 .pptx
最新发布
08-13
集团信息化顶层规划 .pptx
Cppcheck使用手册：代码缺陷检测指南
"cppcheck的使用手册，涵盖了从基础到高级的cppcheck功能，包括代码检测、错误严重性设置、结果保存、多线程检查、预处理器配置、XML输出、错误抑制、内存泄漏检查、HTML报告和图形用户界面等。" `cppcheck` 是一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值