C++ 命名空间、引用、指针、容器、强转、类、友元函数、友元类、单例、重载操作符、继承、多态、虚函数、模板（泛型）

最新推荐文章于 2024-06-04 22:55:58 发布
最新推荐文章于 2024-06-04 22:55:58 发布
阅读量166 收藏 1
点赞数
分类专栏： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tpsu888/article/details/106686225
版权

命名空间
类似包名 区分重名

using namespace std;


//命名空间
namespace first_space {
    void fun() {
        cout << "first_space" << endl;
    }
}
namespace second_space {
    void fun() {
        cout << "second_space" << endl;
    }
}



int main(int argc, const char * argv[]) {
	//命名空间
    first_space::fun();
    second_space::fun();
	return 0;
}

//first_space
//second_space

引用 和 指针
在这里插入图片描述

引用直接用& 即可
int& r = xxxx;

//引用
    int iforYinYong = 10;
    double dforYinYong = 9.0;
    int* pYinYong = &iforYinYong;  //指针
    int& r = iforYinYong;	//引用
    cout << "Value of iForYinYong reference: " << r << endl;

容器

#include <vector>
#include <set>
#include <map>

int main(int argc, const char * argv[]) {
	//容器  stl： 标准模板库
    //序列式 关联式
    //序列式容器：元素排列顺序 与 元素本身 无关，由添加顺序决定。 stack
    //vector list dequeue queue stack priority queue
    vector<int> vec1;
    //声明 一个元素空间
    vector<int> vec2(1);
    //6个元素 值都是1
    vector<int> vec3(6, 1);
    
    vector<int> vec4(vec3);
    //添加元素
    vec1.push_back(10);
    //通过下标 获取元素
    cout << "通过下标获取元素：" << vec1[0] << endl;
    //获取对头 队尾的元素
    vec1.front();
    vec1.back();
    vec1.clear();//清空
    vec1.erase(vec1.begin(), vec1.end());//区间
    cout << "容器大小： " << vec1.capacity() << endl; //容器大小
    
    //关联式 set map hashmap
    //set 集合  元素不可重复
    set<int> set1 = {1, 2, 3, 4};
    set1.insert(1); //已存在 不会加进去
    pair<set<int>::iterator, bool> _pair = set1.insert(6); //返回值 添加了什么，是否成功
    std::cout << "set集合里元素个数有：" << set1.size() << endl;
    set<int>::iterator itt = set1.begin();
    set1.end();//最后一个元素的 下一个元素
    for (; itt != set1.end(); itt++) {
        cout << *itt << endl;
    }
    
    //map
    map<int, string> map1;
    map<int, string> map2 = {{1, "a"}, {2, "b"}};
    map2.insert({3, "c"});
    //修改
    map2[1] = "d"; //1是key
    map<int, string>::iterator ittm = map2.begin();
    for (; ittm != map2.end(); ittm++) {
        cout << ittm->first << ":" << ittm->second << endl;
    }
}

c的强转
在这里插入图片描述

C++ 分四种转换
在这里插入图片描述

在这里插入图片描述

class Parent {
public:
    void test() {
        cout << "p" << endl;
    }
};
class Child: public Parent {
public:
    void test() {
        cout << "c" << endl;
    }
};


//强转
    //const_cast  相互转化
    const char *a7; //相当于java的final
    char *b7 = const_cast<char*>(a7);
    char *a8;
    const char *b8 = const_cast<const char*>(a8);
    //static_cast  基本类型转换  父子转换   编译时
    Parent *parent = new Parent;
    Child *c = static_cast<Child*>(parent);
    c->test();
    //dynamic_cast  运行时

类
通过有缘函数或者有缘类 可以访问修改私有成员

头文件 Student.h

#ifndef Student_h
#define Student_h
class Student {
    //友元函数
    friend void test(Student*);
    //友元类
    friend class Teacher;
    int i;
    
public:
    Student(int i, int j);
    ~Student();//析构函数
    
    void setJ(int j);
    
    void setK(int j) const;
    
    int getB() {
        return b;
    }
    
    int getA() {
        return a;
    }
    
    private:
    int a;

    private:
    int b;

    protected:
    int c;

};
    class Teacher {
        public:
        void call(Student* s) {
            s->a = 1000;
        };
    };



#endif /* Studentr_h */

Student.cpp

#include "Student.hpp"
#include "Student.h"
#include <iostream>
using namespace std;

//相当于安卓里的 onCreate
Student::Student(int i, int j):i(i) {
    //:i(i) 省去写this 直接给成员变量赋值
//    this->i = i;
    cout << "构造方法" << endl;
}

//可以通过方法给成员变量赋值
void Student::setJ(int j) {
    this->a = j;
}
//常量函数
//表示不会 也不允许 修改类中的成员
void Student::setK(int j) const{
//    this->a = j;
}



//相当于安卓里的 onDestroy
Student::~Student() {
    cout << "析构方法" << endl;
}

main函数

#include <iostream>
#include "Student.h"

void test(Student* stu) {
    stu->b = 100;
}

int main(int argc, const char * argv[]) {
    //构造
    Student student(10, 20);
    test(&student);
    
    std::cout << student.getB() << std::endl;
    
    Teacher teacher;
    teacher.call(&student);
    
    std::cout << student.getA() << std::endl;
    return 0;
}

单例
Single.h

class Single{
private:
    static Single* instance;
    Single();
    

public:
    static Single* getInstance();
};

Single.cpp

#include "Single.hpp"
#include "Single.h"
Single* Single::instance = 0;

Single* Single::getInstance() {
    if (!instance) {
        instance = new Single();
    }
    return instance;
};

main

#include <iostream>
#include "Single.h"

int main(int argc, const char * argv[]) {
    Single* single = Single::getInstance();
    std::cout << single <<  std::endl;
    return 0;
};

操作符
Test.h

#ifndef Test_h
#define Test_h
class Test {
public:
    int i;
    Test operator + (const Test& t) {
        Test temp;
        temp.i = this->i + t.i;
        return temp;
    };
};

#endif /* Test_h */

main

#include <iostream>
#include "Test.h"
int main(int argc, const char * argv[]) {
    Test test1;
    test1.i = 100;
    Test test2;
    test2.i = 200;
    
    Test test3 = test1 + test2;
    std::cout << test3.i << std::endl;
    return 0;
}

继承
多态：父类引用指向子类对象
静态多态，调用的是父类方法。
动态多态，调用子类方法。
Extend.h

#ifndef Extend_h
#define Extend_h
#include <iostream>
using namespace std;
class Parent1 {
public:
    //动态多态
    virtual void eatting() {
        cout << "parent1" << endl;
    }
    
    //纯虚函数 类似抽象方法
    virtual void abstractMethod() = 0;
};

class Parent2 {
public:
    void eatting() {
        
    }
};

class Child : public Parent1, Parent2 {
public:
    void eatting() {
        //super.eatting()
        Parent1::eatting();
        cout << "child" << endl;
    }
    
    //子类实现 纯虚函数  也就是抽象方法
    void abstractMethod() override {
        cout << "子类重写了父类的 抽象方法" << endl;
    };
};


#endif /* Extend_h */

main

#include <iostream>
#include "Extend.h"
int main(int argc, const char * argv[]) {
    Child child;
    child.eatting();
    
    
    //静态多态
    Parent1* child2 = new Child();
    child2->eatting(); // 因为是静态 在编译时期，就认为是parent1的eatting方法，没等创建child呢。
    
    //动态多态 需要把 Parent1类的方法前 加关键字 virtual
    //将其声明为虚函数
    //注意事项：1、构造方法永远不要设置为虚函数  如果父类是 虚函数构造，子类就没办法创建了
    //       2、析构方法 声明为虚函数  好让真正的子类去释放内存
    
    return 0;
}

模板（泛型）

#include <iostream>
//泛型基础 模板编程
   //函数模板  java的泛型方法
   /**
        T method(T t) {}
    */
   template <typename T>
   T methodA(T t1, T t2) {
       return t1 > t2 ? t1: t2;
   }

//类模板  java的类泛型
    template <class T, class E>
class Q {
public:
    T test(T t, E e) {
        return t + e;
    }
};

int main(int argc, const char * argv[]) {
   //方法模板
    int result = methodA(1, 2);
    std::cout << result << std::endl;
    //类模板
    Q<int, float> q;
    std::cout << q.test(1, 2.0) << std::endl;
    return 0;
}
zyaire_小佟
关注
专栏目录
Kotlin函数篇
Robin Hu的专栏
04-16 555
本文整理自：https://chiclaim.blog.csdn.net/article/details/88624808 一、Kotlin 函数的基本定义 我们先来定义一个基本的函数： fun max(a: Int, b: Int): Int { return if (a > b) a else b } 解释一下 fun 关键字用来定义一个函数 fun 关键字后面是...
关联容器、友元
qq_35712835的博客
10-02 144
1 .map 中的元素是一些 关键字--值（key-value） 对 ：关键字起到索引的作用，值表示与索引相关联的数据。     字典就是一个使用map很好的例子：可以将单词作为关键字，单词的释意作为值。 2 . set 关键字即值，即只保存关键字的容器。       个人感觉 set 一般配合 map 使用，对某些关键字的一些特别操作等。   3. 类可以允许其他类或者函数访问它的非公...
C++友元知识点详解
渐行渐远
04-06 1967
1.何为友元？ 类可以允许其他类或者函数访问它的非公有成员，方式是令其他类或者函数成为它的友元(需要用到friend关键字)。 2.友元分类 3.非成员函数作为友元函数 示例代码结构如下： #ifndef STUDENT_HPP #define STUDENT_HPP class Student { public: friend void ModifyAge( Student &stu, int value ); Student():age(18){}
不知道对错 指针与引用
天蝎座
10-15 623
1.从内存上来讲  系统为指针分寸内存空间，而引用与绑定的对象共享内存空间，系统不为引用变量分配内容空间。 2指针初始化以后可以改变指向的对象，而引用定义的时候必须要初始化，且初始化以后不允许再重新绑定对象。 3.所以引用访问对象是直接访问。指针访问对象是间接访问。 4。如果pa是指针，那么*pa就是引用了。 但是两者在作为形参的时候非常相似，区别是指针拷贝副本，引用不拷贝。程序如下：
我的经验：指针和指针的引用
大周辞寒的专栏
05-28 3776
我一下讨论的都是在不用return把值进行返回的情况， 也就是说用指针的情况。很简单就是指针和引用，引用在新版本的c里面也有包含，可以使用。系统xp+ide用的 vc6.0：要把一个值通过调用函数改变，可以用指针和引用，这个值可以是int int *,char char*,或者说是结构体，结构体也有不同的情况，比如说，结构里面有结构体指针和没有的情况，这里我将就我的经历写一下。
【C++】C++类的学习（三）——运算符重载与友元函数
不用先生的博客
04-09 4076
  【fishing-pan：https://blog.csdn.net/u013921430转载请注明出处】 前言        前面的两篇博文中介绍了类的一些基本特性，今天讲一讲运算符重载和友元。 运算符重载       运算符重载是C++中一种形式的多态，运算符重载将重载的概念运用到运算符上，赋予运算符更多地含义。也许乍然一听，似乎我们对它并不熟悉，其实它一直为我们使用，例如 * ...
C++ 操作符重载形式——成员函数 or 友元函数
Dablelv 的博客专栏。
02-10 4854
运算符重载是C++多态的重要实现手段之一。通过运算符重载对运算符功能进行特殊定制，使其支持特定类型对象的运算，执行特定的功能，增强C++的扩展功能。运算符重载的我们需要坚持四项基本原则： （1）不可臆造运算符； （2）运算符原有操作数的个数、优先级和结合性不能改变； （3）操作数中至少一个是自定义类型； （4）保持重载运算符的自然含义。一般来说，C++运算符重载可采用成员函数和友元函数，二者
C++基础与深度解析 | 类进阶 | 运算符重载 | 类的继承 | 虚函数
zwcslj的博客
06-04 858
运算符重载允许程序员定义或修改已有运算符对用户定义类型（如类）的操作。例如，可以为自定义的类重载+运算符，以实现两个对象的加法操作。 继承是面向对象编程的一个核心概念，它允许一个类（称为子类或派生类）继承另一个类（称为基类或父类）的属性和方法。 虚函数是可以在派生类中被重写的函数，它们是实现多态的关键。
C++的友元函数和友元类
weixin_44705391的博客
04-06 615
6.C++的友元函数和友元类 1.什么是友元函数 1.1、外部函数访问类内成员 (1)写一个Person类，内部有private、protected、public的三类访问权限的成员 (2)写一个外部函数disp_info来打印这三类成员 (3)代码实战 (4)总结：可以访问public的，但是protected和private的无法访问 (5)想办法：除非把disp_info挪到Person类内部成为成员函数，否则没办法 1.2、友元函数的引入 (1)将外部函数disp_info声明为Person类的友元
【C++ 七】类和对象：封装、继承、多态、友元、运算符重载
qq_45138120的博客
04-20 1333
本文包含封装的意义、struct和class区别、成员属性设置为私有、构造函数和析构函数、构造函数的分类及调用、拷贝构造函数调用时机、构造函数调用规则、深拷贝与浅拷贝、初始化列表、类对象作为类成员、静态成员、成员变量和成员函数分开存储、this指针概念、空指针访问成员函数、const修饰成员函数、全局函数做友元、类做友元、成员函数做友元、加号运算符重载、左移运算符重载、递增运算符重载、递减运算符重载、赋值运算符重载、关系运算符重载、函数调用运算符重载、继承的基本语法、继承方式、继承中的对象模型......
C++基础知识 —— 内存分区模型、引用、函数重载、类和继承、this指针、友元、多态、文件操作
不善挽留
03-27 629
1. 内存分区模型、2. 引用、3. 函数提高、4. 类和对象、5. 文件操作
C++运算符重载为友元函数的多态应用与规则详解
重载方法重载为类的友元函数是C++编程中实现多态性的一种方式，特别是在处理运算符时。C++中的多态性允许同一个名字对应多个具有相似功能但具体实现各异的函数，增强了代码的灵活性和表达力。在运算符重载中，C++...
笔记②：牛客校招冲刺集训营---C++工程师（面向对象（友元、运算符重载、继承、多态） -- 内存管理 -- 名称空间、模板（类模板/函数模板） -- STL）
weixin_38665351的博客
07-21 2293
通过父类对象访问父类中的非静态成员和静态成员；通过子类对象访问子类中的非静态成员和静态成员；通过子类对象访问父类中的非静态成员和静态成员；不通过对象来访问，直接加个作用域行不行?静态成员可以直接加个作用域来访问，非静态成员必须通过特定的对象来访问。方式4的理由由于静态成员（变量和函数）被所有对象共享，所以一般不通过子类对象来访问这些同名成员，而是直接加上父类类名的作用域来访问；但非静态成员就必须要通过具体的对象来访问了。publicintnum1;，而虚拟内存排序。..................
C++:友元函数，有这一篇就够了
qq_44851228的博客
11-23 499
  在学习C++时，关于友元类和友元函数这一小节，感觉比较难理解，这篇就来一起研究关于友元的相关知识吧~ 我们将从以下几点深入剖析友元函数： 为什么要引入友元函数？ 什么时候使用友元函数？ 怎样使用友元函数？ 友元函数的优缺点有哪些？ 友元函数 1.引入友元函数的原因 ...
C++运算符重载：成员函数与友元函数的应用
运算符重载可以作为类的成员函数或者友元函数来实现。 在C++中，运算符重载为成员函数时，通常会有一个形参是当前对象的引用，这使得运算符能够作用于对象自身。例如在描述中的“例4.2”中，重载的加法运算符`+`...
用于项目样式reset的资源
11-03
用于项目样式reset的资源
pytz-2016.10.tar.bz2
最新发布
11-03
pytz库的主要功能 时区转换：pytz库允许用户将时间从一个时区转换到另一个时区，这对于处理跨国业务或需要处理多地时间的数据分析尤为重要。 历史时区数据支持：pytz库不仅提供了当前的时区数据，还包含了历史上不同时期的时区信息，这使得它在处理历史数据时具有无与伦比的优势。 夏令时处理：pytz库能够自动处理夏令时的变化，当获取某个时区的时间时，它会自动考虑是否处于夏令时期间。 与datetime模块集成：pytz库可以与Python标准库中的datetime模块一起使用，以确保在涉及不同时区的场景中时间的准确性。
VB程序实例-判断键盘按下的键值.zip
11-03
VB程序实例-判断键盘按下的键值.zip
VB程序实例-控制其他程序成为自己的子窗体.zip
11-03
VB程序实例-控制其他程序成为自己的子窗体.zip
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值