20170602

1 #include <iostream>
  2 using namespace std;
  3 class A {
  4     public:
  5         static void show(A *mythis) {//mythis是自己模拟this指针,做了编译器做的事情,本来静态方法不能访问非静态,原因是静态没有自己的this指针,我们加上以后,就可以了
  6             mythis->play();
  7         }
  8         void play() {
  9             cout << "this is play()" << endl;
 10         }
 11 };
 12 int main() {
 13     A a;
 14     A::show(&a);
 15 }
单例模式:整个程序中只有一个这个类型对象,比如任务管理器,不管你调几次,都只能出来 一个
多例:比如文件夹,可以点开N次

单例模式:共享池
静态成员变量
防止类外创建对象 私有构造 拷贝构造
静态函数 提供外界访问接口
饿汉式:立即会创建出对象
懒汉式:需要对象时才去创建
  1 #include <iostream>
  2 using namespace std;
  3 class Singleton {
  4     private: //私有化构造,拷贝构造,防止类外创建
  5         Singleton() {};
  6         Singleton(const Singleton& s) {};
  7         static Singleton sig;//提供静态成员 类外初始化
  8     public: //提供公开的得到对象的接口,使用类型就可以得到对象
  9         static Singleton& getInstance() {
 10             return sig;
 11         }
 12 };
 13 Singleton Singleton::sig;//静态初始化,前面类型,后面变量名
 14 int main() {
 15     Singleton& sig1 = Singleton::getInstance();
 16     Singleton& sig2 = Singleton::getInstance();
 17     cout << &sig1 << endl;
 18     cout << &sig2 << endl;
 19 }
 
一、成员指针
    struct Date {
        int year;
        int month;
        int day;
    };
    1.1 指向成员变量的指针
    int Date::*pmem; //成员指针,普通指针前面加类名::修饰。
    pmen = &Date::year;//成员指针的赋值
    Date date;
    date.*pmem;//通过成员得到值
    Date *date2 = new Date();
    date2->*pmem;
 
 
  1 #include <iostream>
  2 using namespace std;
  3 class Date {
  4     public:
  5         int year;
  6         int month;
  7         int day;
  8         Date(int year = 0, int month = 0, int day = 0):year(year    ),month(month),day(day) {
  9
 10         }
 11 };
 12
 13 int main() {
 14     //定义一个Date类型对应的成员指针
 15     int Date::*pmem;
 16     //赋值
 17     pmem = &Date::year;
 18     Date date(2017,5,31);
 19     cout << date.*pmem << endl;
 20     pmem = &Date::day;
 21     cout << date.*pmem << endl;
 22 }
 
 
本质:
成员变量指针的本质就是对象的地址偏移量
 
 1.2 成员函数指针(代码区的函数的地址)
 struct Date {
        int year;
        int month;
        int day;
        void showYear() {
            cout << year << endl;
        }
 };
 /*定义成员函数指针*/
 void (Date::*pfun)();
 /*赋值*/
 pfun = &Date::showYear;
 Date date;
 //通过对象调用指针对应的函数
 (date.*pfun)();
 Date *date2 = new Date();
 (date2->*pfun)();
 
  1 #include <iostream>
  2 using namespace std;
  3 class Date {
  4     public:
  5         int year;
  6         int month;
  7         int day;
  8         Date(int year = 0, int month = 0, int day = 0):year(y    ear),month(month),day(day) {
  9
 10         }
 11         void showYear() {
 12             cout << year << endl;
 13         }
 14         void showMonth() {
 15             cout << month << endl;
 16         }
 17 };
 18
 19 int main() {
 20     void (Date::*pfun)();
 21     pfun = &Date::showYear;
 22     Date date(2017,5,31);
 23     (date.*pfun)();
 24     Date *date1 = new Date();
 25     pfun = &Date::showMonth;
 26     (date1->*pfun)();
 27 }
 
 
 二、运算符重载
    2.1 本质:
    就是函数的特殊表现形式
    2.2 分数:
    分数的特征
        分子
        分母
    分数的功能
        显示一个分数
        分数的相加(全局函数两个分数相加)
  1 #include <iostream>
  2 using namespace std;
  3 class Fraction {
  4     public:
  5         int x;
  6         int y;
  7         Fraction(int x = 0,int y = 1):x(x),y(y) {
  8
  9         }
 10         void show() {
 11             cout << x << "/" << y << endl;
 12         }
 13 };
 14 /*设计一个函数实现两个分数相加*/
 15 const Fraction add(const Fraction& f1,const Fraction& f2) {
 16     return Fraction(f1.x*f2.y+f1.y*f2.x,f1.y*f2.y);
 17 }
 18 int main() {
 19     Fraction fa(1,3);
 20     fa.show();
 21     Fraction fb(1,2);
 22     Fraction fc = add(fa,fb);
 23     fc.show();
 24 }
 
 L#R(#是操作符) 去L对象对应的类型中找一个成员函数operator#(R对象对应的类型par)
 如果没有,就去全局区找一个全局函数operator#(L对象对应的类型par1,R对象对应的类型par2);
 如果还没有发现就报错。
  1 #include <iostream>
  2 using namespace std;
  3 class Fraction {
  4     public:
  5         int x;
  6         int y;
  7         Fraction(int x = 0,int y = 1):x(x),y(y) {
  8
  9         }
 10         void show() {
 11             cout << x << "/" << y << endl;
 12         }
 13 };
 14 /*设计一个函数实现两个分数相加*/
 15 const Fraction operator+(const Fraction& f1,const Fraction& f2) {
 16     return Fraction(f1.x*f2.y+f1.y*f2.x,f1.y*f2.y); //Fraction();这是一个临时对象
 17 }
 18 int main() {
 19     Fraction fa(1,3);
 20     fa.show();
 21     Fraction fb(1,2);
 22     //Fraction fc = add(fa,fb);
 23     Fraction fc = fa + fb;
 24     fc.show();
 25 }
 
 成员形式的+号运算符
 f1+f2 f1.operator+(f2)

const Fraction operator-(const Fraction f2) {
       return Fraction((x*f2.y-f2.x*y),(y*f2.y));
 }
 
 2.3 设计一个类,包装一个整数
    integer
    成员变量
    int data;
    函数:
    构造函数 负责赋值
    提供两个整数相加相乘的运算符支持
    判断两个整数是否相等(值相等)
    显示这个整数的值
  1 #include <iostream>
  2 using namespace std;
  3 class Integer {
  4     public:
  5     int data;
  6     Integer(int data) {
  7         this->data = data;
  8     }
  9     Integer operator+(Integer in) {
 10         return Integer(data+in.data);
 11     }
 12     Integer operator*(Integer in) {
 13         return Integer(data*in.data);
 14     }
 15     bool operator==(Integer in) {
 16         return data==in.data;
 17     }
 18     void show() {
 19         cout << data << endl;
 20     }
 21 };
 22
 23 int main() {
 24     Integer a(10);
 25     Integer b(20);
 26     Integer e(20);
 27     Integer c = a + b;
 28     c.show();
 29     Integer d = b * a;
 30     d.show();
 31     c = a * b;
 32     c.show();
 33     cout << (b == e) << endl;
 34 }

2.4输入输出运算符的重载
ostream        cout;   
instream     cin;    
Integer c;
cout << c;
流对象不允许复制,不允许加const修饰,所以ostream必须引用
 L#R(#是操作符) 去L对象对应的类型中找一个成员函数operator#(R对象对应的类型par)
 如果没有,就去全局区找一个全局函数operator#(L对象对应的类型par1,R对象对应的类型par2);
 如果还没有发现就报错。
 cout.operator<<(Integer c)
 ostream& operator<<(ostream& cout,Integer c)
 返回值设计成ostream&
 
 ostream& os  流不能复制,所以使用引用,流不能加const
 const Integer& par2   const适应输出临时对象和const对象  引用减少拷贝
 
 指针和引用 联系和区别
 联系:引用是指针实现的 所以很多情况 指针可以用引用来代替函数的参数 函数的返回值
 区别:1.引用必须初始化 指针不是必须的
       2.引用一旦初始化 就不能改变绑定的对象 但是可以改变值
         指针可以改变指向
       3.指针是一个实体变量 大小4(32位系统)
         引用是一个别名  大小和引用的对象有关
       4.有指针的指针  没有引用的引用
       5.有指针的引用 int*&
         没有引用的指针 int&*  //error
       6.有指针的数组
         没有引用类型的数组
         int * data[10] = {&a, &b, &c}
         int data[10] = {a,b,c} //a b c的值
       7.有数组的引用
         int data[3];
         int (&rdata)[3];

时间: 2024-10-27 06:30:55

20170602的相关文章

myutil 20170602

#pragma once #include "P645Define.h" #define MYUTIL_VERSION 20170602 class myutil { public: myutil(void); virtual ~myutil(void); static BOOL IsIntInRange(int value, int min, int max); static void SetIntInRange(int &value, int minval, int max

【2017-06-02】Jquery基础

Jquery就是Js集成的一些方法包. 注意:Jquery的引入位置在<head></head>里. 一.选择器 1.Id选择器 $("#div1") 2.Class选择器 $(".div") 用class选择器选出一堆对象给他们附事件,不用像Js一样遍历.直接附加事件,取到的所有对象都会附上事件. 注意:Js中的this,在Jquery中变为$(this). 3.标签选择器 $("div") 4.并列选择器 用,隔开 $

【T-SQL】系列文章全文目录(2017-06-02更新)

本系列[T-SQL]主要是针对T-SQL的总结. T-SQL基础 [T-SQL基础]01.单表查询-几道sql查询题 [T-SQL基础]02.联接查询 [T-SQL基础]03.子查询 [T-SQL基础]04.表表达式-上篇 [T-SQL基础]04.表表达式-下篇 [T-SQL基础]05.集合运算 [T-SQL基础]06.透视.逆透视.分组集 [T-SQL基础]07.数据修改 [T-SQL基础]08.事务和并发 [T-SQL基础]09.可编程对象 T-SQL进阶 [T-SQL进阶]01.好用的SQ

常用模块

1.import讲解#本质就是.py 文件,用来从逻辑上组织pyhton代码(变量.函数.类.逻辑,实现一个功能) 1.1.导入方法导入多个模块,以逗号隔开 例如 module模块: name = "kangkang" def fun(num): print("num",num) 1) import module print(module.name) #调用模块下的参数 module.fun(23) #调用模块下的方法 结果为: kangkang num 23 2)

mysql-查询

select查询 select查询语句: 语法: ( select field_name ... from tb_name where 查询条件 group by field_name ... having 过滤条件 (分组查询和分组查询过滤) order by field_name asc(升序) desc(降序) (查询结果排序) limit ) where 和 having 都有条件判断的功能(过滤)区别:    where 是在分组之前进行过滤    haing 是在分组之后进行过滤 1

浅谈编码习惯之注释篇

软件编码过程中,当注释代码时,要考虑到不仅将来维护你代码的开发人员要看,而且你自己也可能要看.用Phil Haack大师的话来说就是:"一旦一行代码显示屏幕上,你也就成了这段代码的维护者".因此,对于我们写得好(差)的注释而言,我们将是第一个受益者(受害者).以下是我个人的简单看法和平常的习惯. 1.模块注释 在一个程序模块的开始,应用注释说明模块的名字.功能.开发者和日期和版本变更历史,如下所示: /******************************************

数据库:MySQL(单表的表记录的操作)(二)

一.表记录的增删改查 1.增加表记录 <1>插入一条记录: insert [into] tab_name (field1,filed2,.......) values (value1,value2,.......); 示例: insert into employee_new (id,name,birthday,salary) values (1,'yuan','1990-09-09',9000); insert into employee_new values (2,'alex','1989-

网络编程 -- RPC实现原理 -- Netty -- 迭代版本V4 -- 粘包拆包

网络编程 -- RPC实现原理 -- 目录 啦啦啦 V2--Netty -- new LengthFieldPrepender(2) : 设置数据包 2 字节的特征码 new LengthFieldBasedFrameDecoder(65535, 0, 2, 0, 2) :  65535 :数据包长度.0:分隔符偏移值.2:分隔符长度.0:数据包偏移值.2:数据包长度. Class : Server package lime.pri.limeNio.netty.netty04; import j

pt-query-digest

pt-query-digest 可以用来分析binlog.General log.slowlog,也可以通过show processlist或者通过tcpdump抓取的MySQL协议数据来进行分析 用法: (1)直接分析slow日志: pt-query-digest INDEX01184W-slow.log > slow_report1.log (2)分析最近12小时内的查询: pt-query-digest --since=12h INDEX01184W-slow.log > slow_re