qq_58665528的博客

原创 c++将24位bmp转8位bmp灰度, 8位bmp灰度反色，24位转3张8位bmp灰度图

首先我们需要定义组成bmp的四部分的结构体#pragma onceusing BYTE = unsigned char;//1using WORD = unsigned short;//2using DWORD = unsigned int;//4using LONG = unsigned long;//4#pragma pack(push)#pragma pack(2)//保证编译器为该数据结构分配内存每次是2个字节struct BITMAPFILEHEADER { W.

原创 BMP文件存储格式

BMP存储格式：BMP文件头（BITMAPFILEHEADER） 位图信息头（BITMAPINFOHEADER） 位图颜色表（RGBQUAD） 位图像素数据BMP文件头//WORD:2字节（自定义数据结构）//DWORD:4字节（自定义数据结构）typedef struct tagBITMAPFILEHEADER { WORD bfType;//文件标识符，存储BM两个字母 DWORD bfSize;//文件大小 WORD bfReserved1;//存储 0..

原创 图像的存储格式

按颜色深度分类，常用的有：黑白图像（二值图像） 8位索引图像 灰度图像 24位真彩色图像黑白图像8为索引图像矩阵中的值就是右表中的索引号灰度图像特点是：颜色表的三个分量相等24位真彩色即：一个像素的颜色由三个字节表示（红，绿，蓝）各占8位图像文件格式：BMP格式 GIF格式（主要用于不同平台的交流和传输，而不是作为文件的存储格式，最大不超64M，颜色最多256色） TIFF格式（扩展性，方便性，可修改性...

原创 数字图像处理概述

色度学理论认为，任何颜色可由红，绿，蓝三种基本颜色混合得到。所以数字图像仅用红，绿，蓝三原色进行表示。f(x, y, z) = {fred(x, y, z), fgreed(x, y, z), fblue(x, y, z)}

原创 c++跟踪实例

在实际开发过程中，我们常常通过一个跟踪实例来跟踪我们的代码，以便于不依靠调试器就能发现代码的错误先来看初始Trace类class Trace {public: static bool traceIsActive; //标志跟踪是关闭还是启动 Trace(const std::string& name); ~Trace(); void debug(const std::string& msg);private: std::string theFunc.

原创 C++11 关键字constexpr

constexpr 关键字的功能是使指定的常量表达式获得在程序编译阶段计算出结果的能力，而不必等到程序运行阶段。C++ 11 标准中，constexpr 可用于修饰普通变量、函数（包括模板函数）以及类的构造函数。注意：不是所有情况下都能在编译阶段算出来修饰普通变量#include <iostream>int main(void) { constexpr int n = 1 + 2 + 3; int array[n] = { 1 };}如果去掉constexpr很明..

原创 C++设计模式 单例模式的定义与简单实现

定义：在整个程序的运行过程中，有且只有一个实例化对象。实现#include <iostream>class Singleton {private: static Singleton* m_singer; Singleton() { std::cout << "构造一个Singleton" << std::endl; }public: static Singleton* getInstance() { if (m_singer .

原创 C++11 final和override

final修饰的基类虚函数不能重写class Car {public: virtual void Drive() final {}};//Drive不能被重写override修饰的基类虚函数必须重写class Car {public: virtual void Drive() {}};class Benz : public Car {public: virtual void Drive() override { cout << "Benz-舒适..

原创 C++11 默认控制函数

显示缺省函数class Person {private: int m_a;public: Person(int a) : m_a(a) {} Person() = default; //显示缺省构造函数，让编译器生成一个默认的 Person& operator=(const Person& person);};Person& Person::operator=(const Person& person) = default; //显示缺省构造函数，.

原创 c++11 右值引用

右值：只能放在=右边的值左值：一定可以放在=左边的值左值引用 int a = 10; int& pa = a; int& pb = 10; //错误，不能引用右值 const int& pb = 10; //正确，但其值不可改缺点：就是不能直接引用右值，必须用const，但是用了const值又不能改。右值引用 int&& a = 10;可以直接引用右值，而且可以更改。...

原创 C++11 Lamada表达式

lambda 表达式定义了一个匿名函数，并且可以捕获一定范围内的变量。定义：[ capture list] ( parameters) mutable throw()-> return-type { statement; };capture list：捕获列表parameters：参数列表mutable throw()：异常说明return-type：返回值类型statement：函数体--------------------------------...

原创 C++设计 简单工厂实用工程技术-动态创建对象与配置化并发

DynObj.h#ifndef __DYNOBJ_H#define __DYNOBJ_H#include <map>#include <string>using Constructor = void* (*)(); //定义一个函数指针class CObjFactory {private: //创建一个全局map容器, string->key, 存储 类名和函数 inline static std::map<std::string, Cons.

原创 C++设计模式：简单工厂的定义与基础使用

定义：提供一个创建对象实例的功能，不关心其具体的实现。被创建的类可以是接口（抽象类），也可以是具体的类。类图：实现：#include <iostream>#include <string>class Api {protected: Api(){} //屏蔽构造函数，体现接口public: virtual void test(std::string s) = 0; //纯虚函数};class ImpleOne : public A...

原创 C++11 智能指针

auto_ptr:属于C++98，现在已经不推荐使用，有缺陷（比如：不能用于数组）auto_ptr<Person> p(new Person());//智能指针p指向了堆空间的Person对象需要注意的是：智能指针只能指向堆空间，因为它会自动释放内存，指向栈空间就会出现二次释放内存的情况。shared_ptr：多个shared_ptr可以指向同一个对象，当最后一个shared_ptr再作用域范围内结束时，对象才会被销毁。shared_ptr<Person...

原创 C++11 using关键字

用using声明别名而不是typedeftemplate<typename T>using MyAllocList = std::list<T, MyAlloc<T> > //使用MyAllocList<int> 等价于 使用std::list<int, MyAlloc<int> > template<typename T>struct MyAllocList { typedef std:.

原创 C++11 nullptr关键字

用nullptr初始化指针而不是nullvoid f(int) {} void f(bool) {} void f(void*) {} func(0);//调用f(int)func(true);//调用f(bool)func(NULL);//调用f(int) #define NULL 0 f(nullptr);//调用f(void*)nullptr的优势在于它不再是一个整数类型.你可以理解为它是一个可以指向任意类型的指针.nullptr的类型实际上是std::nul.

原创 C++11 四种类型转换

const_cast：将const转换为非const const int n = 0; int* p = const_cast<int*>(&n);static_cast ：只能用于良性转换。如：整型间的转换 void*和其他指针的转换不能用于：不能将整型转换为指针类型 不能再两个具体类型的指针之间进行转换另外，static_cast再编译期间进行转换，转换失败的话就会抛出一个编译错误#include <iostream>#inclu.

原创 C++11 decltype关键字

decltype也能推导出变量的类型，并且它比auto推得更加的准确，只有极少情况下会出错。 const int i = 0; decltype(i); //const int bool f(const Point& p); decltype(f); //bool (const Point& p)另外值得注意的是，如果出现双括号，就要多加个& const int i = 0; decltype((i)); //const int& boo..

原创 C++11 auto关键字

auto的作用是自动类型推导顶层const与底层const顶层const：修饰左值全部数据类型 底层const：修饰左值部分数据类型const int i = 0; //顶层const, 左值全部数据类型为int, 修饰的也是intconst int* p1 = &i; //底层const, 左值全部数据类型为int*, 修饰的是intint a = 0;int* const p2 = &a; //顶层const, 左值全部数据类型为int*, 修饰的是i..

原创 C++异常

C++中用try，catch和throw来处理异常#include <iostream>int main(void) { using std::cout; using std::endl; cout << 1 << endl; try {// 当try中的语句出现异常就会跳到catch中去 for (int i = 0; i < 99999; i++) { int* p = new int[99999]; } } cat.

原创 C++成员模板，模板的模板参数以及模板的默认参数

#include <iostream>#include <deque>#include <memory>template<typename T, template<typename ELEM, typename = std::allocator<ELEM> > class CONT = std::deque>class Stack{private: std::deque<T> elems;publ..

原创 C++函数模板的重载

函数模板是支持重载的template<typename T>void add(T a, T b){}template<typename T>void add(T* a, T* b){}值得注意的是：这跟模板的偏特化很像，但函数模板没有偏特化。C++模板的特化和偏特化...

原创 C++模板的特化和偏特化

特化#include <iostream>#include <deque>#include <string>#include <stdexcept>//一般化模板template<typename T>class MyStack {};//特化模板 当T为std::string时进行特殊处理template<>class MyStack<std::string>{private: std::.

原创 C++类模板

学了上节的知识，我们再来看看类模板C++函数模板https://blog.csdn.net/qq_58665528/article/details/122424591

原创 C++单例模式

#include <iostream>class Rocket {private: Rocket(); //将构造函数私有化，保证了不能在外部实例化 Rocket(const Rocket& rocket); //将拷贝构造私有化，保证了不能在外部实例化 ~Rocket(); //将析构私有化 static Rocket* msRocket; //创建唯一个Rocket指针 void operator=(const Rocket&..

原创 C++函数模板

泛型：将类型参数化以达到代码复用的技术。C++使用模板实现泛型先看下面代码class Point {private: int m_xPosition; //记录x轴坐标 int m_yPosition; //记录y轴坐标public: Point(int x = 0, int y = 0) : m_xPosition(x), m_yPosition(y) {} //构造函数 初始化 const Point operator+(const Point& point..

原创 C++仿函数

有关常规运算符的重载汇总https://blog.csdn.net/qq_58665528/article/details/122420553#include <iostream>class Sunny {private: int m_age;public: int operator()(int a, int b) { this->m_age = 10; return (a + b) / this->m_age; }};int main(v.

原创 C++调用父类的重载运算符

#include <iostream>class Person {private: int m_age;public: Person(int age) : m_age(age){} Person& operator=(const Person& person) { this->m_age = person.m_age; return *this; } void getAge() { std::cout << this-&..

原创 C++运算符重载（汇总）

讲解部分：C++运算符重载之+，-，*，/https://blog.csdn.net/qq_58665528/article/details/122413141C++运算符重载之=，+=，-=，*=，/=https://blog.csdn.net/qq_58665528/article/details/122414567C++运算符重载==，＜，＞，＜=，＞=https://blog.csdn.net/qq_58665528/article/details/122417755C++运算符重载＜＜，＞＞.

原创 C++运算符重载＜＜，＞＞

C++运算符重载==，＜，＞，＜=，＞=https://blog.csdn.net/qq_58665528/article/details/122417755让我们先来分析分析下面这段语句std::cout << "wuhu" << "dsm";这段话告诉我们的信息有下运算符<<接受两个参数，左边ostream对象std::cout, 右边可以接受一个字符串，另外肯定是要返回一个ostream对象，因为要允许连续的输出字符串，另外应该是返回的引用，这样.

原创 C++运算符重载==，＜，＞，＜=，＞=

运算符重载==，>，<，<=，>=https://blog.csdn.net/qq_58665528/article/details/122414567以==为例1. 对于a == b (a.operator==(b))，我们肯定希望b的值不会改，所以要有const修饰，加上希望减少空间开销，提高效率，所以使用引用。所以，参数的类型为const Point&2. 对于a == b (a.operator==(b))，对于函数的返回值，自然是布尔类型综上得出.

原创 C++运算符重载之=，+=，-=，*=，/=

运算符+，-，*，/的重载https://blog.csdn.net/qq_58665528/article/details/122413141有了上节的思考，我们再来想想运算符=的重载1.对于a = b（a.operator(b)）我们不希望b的值被改变，所以参数b一定有const修饰，接着为了减少空间开销，提高运行效率，用引用要比创建一个新的Point对象要好的多，所以参数的类型为const Point&2. 对于a = b = c(a.operator(b.operator(..

原创 C++运算符重载之+，-，*，/

运算符“+”的重载class Point {private: int m_xPosition; int m_yPosition;public: Point(int xPosition = 0, int yPosition = 0); //构造函数 声明 const Point operator+(const Point& point) const; //重载运算符+ 声明 };//构造函数 定义Point::Point(int xPosition, int y.

原创 C++友元

友元的作用就是允许外面的函数或者类访问自身的私有变量。友元函数#include <iostream>#include <iostream>class Animal { friend void getHisName(Animal a); //声明友元函数private: std::string m_name;public: void getMyName() { std::cout << "My name is : " << .

原创 C++ const成员

const成员变量：1. 必须在类内部初始化2. 非static的可以在初始化列表中初始化#include <iostream>class Student { public: const int m_age; Student(int age = 10) : m_age(10) {}};int main(void) { Student s = Student(); std::cout << s.m_age; return 0;.

原创 C++ static成员

static成员（被static修饰的成员变量/函数）可以通过三个方式访问：1. 对象.静态成员2. 对象指针->静态成员3. 类名::静态成员#include <iostream>class Student { public: static int m_age; static void study();};int Student::m_age = 10; //必须在类外初始化void Student::study() { ...

原创 C++命名空间（名称空间）

命名空间可以规避命名冲突#include <iostream>namespace MJ {int age;void func(int age) { std::cout << "MJ::func() : " << age << std::endl;}}namespace JC {int age;void func(int age) { std::cout << "JC::func() : " <<.

原创 C++ malloc/free与new/delete

malloc/free#include <iostream>int main(void) { int* p = (int*)malloc(4); *p = 10; free(p); return 0;}new/delete#include <iostream>int main(void) { int* p = new int; *p = 0; delete p; const char* s = new char[..

原创 计算机图形学 2D的矩阵变换

原创 C#坦克大战

using System;//使用名称空间Systemnamespace Learning {//创建名为学习Learning 的名称空间 //创建Program类 class Program { //程序的入口函数 static void Main(string[] args) { Console.WriteLine("Hello World!");//输出并换行 Console.Write("Hello World!");//输出不换行 } }}..