c++面向方法编程
2018-11-30 20:00:43 qq_41068877 阅读数 57

为了学校的考试,做一下C++的笔记。

教材是  机械工业出版社/刘振安 的 C++程序设计

不推荐这本书。这本书太薄,很多东西写得不够详细,也不系统。基本上就是应付考试。

百度上面有PPT,估计一周就能看完这三百多页ppt.

https://wenku.baidu.com/view/bb827b2f3868011ca300a6c30c2259010202f381.html


12月1日,昨晚听说 通过C++二级可以免考,所以就不继续看这本书了。 


1.1 认识C++的函数和对象

C语言陈程序包含main函数

(纯)面向对象语言没有main函数

C++是混合型语言

 

1.2 认识C++语言面向过程编程的特点

1.2.1 函数重载

 

1.2.3 动态分配内存

 

1.2.4 引用(别名)

 

1.2.5 对指针使用const

const在谁前,谁就是const(不能修改)

如:

const int *P; //const 在 int前,说明P指的那个int不能修改

int * const P //const 在P前,说明P不能修改,

const int* const P //int 和 P 都不能修改。

 

1.2.6 泛型算法 用于普通数组

头文件<algorithm>

//a,b是数组,长度为len

  1. reverse(a, a+len)
  2. copy(a,a+len,b)
  3. reverse_copy(a,a+len,b);
  4. sort(a,a+len);
  5. sort(a, a+len, greater<type>());//降序。例如:sort(a,a+len,greater<int>());
  6. find(a,a+len,value) //查找,返回位置指针
  7. copy(a,a+len, Ostream_iterator<type>(cout,"分隔符"));

//copy(a,a+len, Ostream_iterator<int>(cout," "));   

//需要头文件 #include<iterator>

 


2.1 结构的演化

2.2 从结构演化成一个类

2.3 面向过程和面向对象

2.4 C++面向对象程序设计特点

2.5 使用类和对象string

size()

substr()复制字串//str = "everyone";str.substr(5,3) 为one //数组从0开始

find("查找内容",起点);

 

getline(cin, str1, '\n') //读取一行

2.5.3 使用complex对象

头文件<complex>

complex<int> num(1,2); //1+j2;

2018-10-20 19:19:00 weixin_34362991 阅读数 7

1. 基本框架

#include<bits/stdc++.h>
using namespace std;

int main(){
    return 0;
}

2. 输入输出

No. 类型 变量 输出 输入
1 整型 int n = 0; printf("%d\n",n); scanf("%d",&n);
2 单精度浮点型 float f = 0; printf("%f\n",f); scanf("%f",&f);
3 字符串 string s; cout << s << "\n"; cin >>s;
4 字符 char c; printf("%c",c); scanf("%c",&c)
5 长整型 long long l; printf("%ldd",l); printf("%lld",&l);

变量名只能英文字母加下划线

小数精确度处理:%.精确度f

整数除法说明
整数除以整数还是整数,如果结果需要是小数,要乘以1.0。例如:
3/2结果为1,1.0*3/2结果为1.5

3. 字符串

  1. 字符串变量string s;
  2. 获取字符串长度s.size()
  3. 获取字符串i位置字符s[i]
  4. 遍历字符串
for(int i=0;i<s.size();++i){
    printf("%c",s[i]);
}
  1. i截取长度为len字符串s.substr(i,len);
  2. i截取到字符串结束s.substr(i);
  3. 字符串字典序排序sort(s.begin(),s.end());
  4. 在字符串后添加n个字符c s.append(n,c);
  5. 字符串连接+,str3 = str1+str2
  6. 构建一个n个字符c组成的字符串string(n,c)

4. 数组

  • 定长数组:数组长度已知,并且数组大小不能改变
  • 变长数组:数组长度未知,并且数组大小可以改变

4.1 一维数组

No. 操作 定长数组 变长数组
1 定义数组 int nums[n]; vector<int> nums;
2 访问下标i元素 nums[i] nums[i]
3 存放数据 nums[i] nums.push_back(数据)
4 数据数量 n nums.size()
  • 遍历向量
    for(int i=0;i<nums.size();++i){
        printf("%d\n",nums[i]);
    }
    

4.2 二维数组

No. 操作 定长数组 变长数组
1 定义数组 int table[n][m]; vector<vector<int> > table;
2 行数 n table.size()
3 列数 m table[i].size()
4 获取第i行第j列数据 table[i][j] table[i][j]
  • 向量存储数据
      vector<vector<int> > table;
      vector<int> row1;
      row1.push_back(1);
      row1.push_back(3);
      row1.push_back(4);
      row1.push_back(5);
      row1.push_back(6);
      vector<int> row2;
      row2.push_back(2);
      row2.push_back(7);
      row2.push_back(10);
      vector<int> row3;
      row3.push_back(8);
      row3.push_back(9);
      table.push_back(row1);
      table.push_back(row2);
      table.push_back(row3);
    
  • 向量遍历
      for(int i=0;i<table.size();++i){
          for(int j=0;j<table[i].size();++j){
              printf("%d ",table[i][j]);
          }
          printf("\n");
      }
    

5. 排序

  • 排序函数sort(开始位置,结束位置)
  • 按照cmp方式排序sort(开始位置,结束位置,cmp)

sort()默认以字典序排列字符,以升序排列数字。

  • 按照字典逆序排列字符串
#include <bits/stdc++.h>
using namespace std;

bool cmp(char a,char b) {
  return a > b;// 正确的顺序
}

int main() {
   string s; // s[i]
   cin >> s;
   sort(s.begin(),s.end(),cmp);
   cout << s;
   return 0;
}
  • 按照降序排列数列
#include <bits/stdc++.h>
using namespace std;

bool cmp(int a,int b){
  return a > b;// 正确的顺序
}

int main() {
   int n = 0;
   scanf("%d",&n);
   int nums[n];
   for(int i=0;i<n;++i){
     scanf("%d",&nums[i]);   
   }
   sort(nums,nums+n,cmp);
   for(int i=0;i<n;++i){
     printf("%d ",nums[i]);   
   }
   
   return 0;
}

6. 结构体

把多个变量绑到一起的一个类型,可以把结构体看成一个多个变量组成包。

struct 结构体{
  变量...
};

例如:
定义结构体

struct UserInfo{
  string name;
  int age;
  bool sex;
};

使用

UserInfo zhangsan;
zhangsan.name = "张三";
zhangsan.age = 31;
zhangsan.sex = true;

结构体数组

UserInfo users[n];
users[i].name
users[i].age
users[i].sex

7. 查找

  • 排序函数find(开始位置,结束位置,查找值)
    如果找到了,返回查找值位置,反之,返回结束位置。

8. 集合set

set<类型> 集合名
插入数据集合名.insert(数据);
删除数据集合名.erase(数据);
set里面没有重复的值,不能使用[下标]访问。
集合里面存放数据数目集合名.size()

set<string> resset;
resset.insert("00");
resset.insert("10");
resset.insert("11");
resset.insert("01");
resset.insert("00");
resset.insert("01");
resset.insert("00");
resset.insert("00");
resset.insert("01");
resset.insert("00");
resset.insert("01");
// 集合不能使用resset[0];
for(string s:resset){
    cout << s << '\n';
}

数据不允许重复,使用集合set<>

9. 基于范围for循环

int nums[4];
nums[0] = 1;
nums[1] = 2;
nums[2] = 3;
nums[3] = 4;
// 基于下标的for循环
for(int i=0;i<4;++i){
    printf("%d\n",nums[i]);
}
// 基于范围的for循环
for(int n:nums){
    // n相当于nums[i]
    printf("%d\n",n);
}

10. 指针

指针是用来存放变量的地址。使用类型 *定义指针,
*指针变量使用指针。
如果指针类型是结构体,使用->访问结构体的变量。

#include <bits/stdc++.h>
using namespace std;
int main() {
    int a = 0;
    printf("%d\n",a);
    int *p = &a;
    *p = 10;
    printf("%d\n",a);
}

11. 链表

数组类型 数组名[n]

#include <bits/stdc++.h>
using namespace std;
// 链表节点 = 数据 + 索引(指针) 
struct Node{
  int data;
  Node *p;
};
// 10 7 5 3 2 1
int main() {
    // 构造链表
    Node head; // 头节点(链表的首节点)
    head.data = 10;
    
    Node n1;
    n1.data = 7;
    head.p = &n1;
    
    Node n2;
    n2.data = 5;
    n1.p = &n2;
    
    Node n3;
    n3.data = 3;
    n2.p = &n3;
    
    Node n4;
    n4.data = 2;
    n3.p = &n4;
    
    Node n5;
    n5.data = 1;
    n4.p = &n5;
    n5.p = NULL; // n5后面没有节点了NULL。
    
    // 遍历链表
    Node* pNode = &root;
    while(pNode != NULL){
        printf("%d ",pNode->data);
        pNode = pNode->p;
    }
}

先进先出LIFO
使用vector<>模拟栈。

    vector<char> test;
    test.push_back('/');
    test.push_back('a');
    test.push_back('b');
    test.push_back('c');
    test.pop_back();
    test.push_back('d');
    test.pop_back();
    test.pop_back();
    for(int i=0;i<test.size();++i){
        cout << test[i] << "\n";
    }

栈的主要用途是,解决括弧匹配问题。

#include <bits/stdc++.h>
using namespace std;
bool check(string s){
    vector<char> stack;
    for(int i=0;i<s.size();++i){
        if(s[i] == '['){
            stack.push_back('[');
        }else if(s[i] == ']'){
            if(stack.empty()){// 如果前面没有做左括号,不匹配
                return false;
            }
            stack.pop_back();
        }
    }
    return stack.empty();
}
int main(){
    string s = "[[[]]][][][][][][][]";
    
    printf("%d\n",check(s));
    
    return 0;
}

特殊函数

累加函数accumulate(first,last,init),累加序列[first,last)区间中的数据,init是累加初始值

struct Node{// 双亲孩子表示法
    vector<int> children;
};

void DFS(int root,Node* nodes){// 深度优先遍历
    stack<int> s;
    s.push(root);
    while(!s.empty()){
        int now = s.top();
        s.pop();
        printf("%d ",now); // 出栈访问
        vector<int> children = nodes[now].children;
        for(int i=children.size()-1;i>=0;--i){
            int post = children[i];
            s.push(post);
        }
    }
}

void BFS(int root,Node* nodes){// 广度优先遍历
    queue<int> s;
    s.push(root);
    printf("%d ",root); // 入队访问
    while(!s.empty()){
        int now = s.front();
        s.pop();
        vector<int> children = nodes[now].children;
        for(int i= 0;i<children.size();++i){
            int post = children[i];
            s.push(post);
            printf("%d ",post); // 入队访问
        }
    }
}

深度遍历递归写法

void DFS2(int root,Node* nodes){// 深度优先遍历
    printf("%d ",root); // 出栈访问
    vector<int> children = nodes[root].children;
    for(int i= 0;i<children.size();++i){
        int post = children[i];
        DFS2(post,nodes);
    }
}
2019-01-15 22:49:35 weixin_43293737 阅读数 57

面向抽象类编程(面向一套预先定义好的接口编程):
1.其实就是不同模块的解耦合,
2.其本质是:就相当于以前的同名函数问题,子类和父类存在同名函数,必须用virtual关键字修饰,使其可以具备多态性质,但是现在将父类中的同名函数=0,构成了纯虚构函数

#include <iostream>
using namespace std;
class Interface1//接口1//也叫抽象类
{
public:
	virtual int add(int a, int b) = 0;//纯虚构函数,子类必须去实现(必须强制替代实现)
	virtual void print() = 0;//纯虚构函数
};
class Interface2//接口2
{
public:
	virtual int mult(int a, int b) = 0;//纯虚构函数
	virtual void print() = 0;
};
class Parent
{
public:
	int getA()
	{
		a = 0;
		return a;
	}
private:
	int a;
};
class  Child : public Parent, public Interface1, public Interface2//多继承
{
public:
	virtual int add(int a, int b)//必须实现纯虚构函数
	{
		cout << "Child: add()已经执行\n";
		return a + b;
	}
	virtual void print()
	{
		cout << "Child: print()已经执行\n";
	}
	virtual int mult(int a, int b)
	{
		cout << "Child: mult()已经执行\n";
		return a*b;
	}
};
//在抽象类函数多继承中,不会出现多继承的二义性,因为抽象类函数必须在子类中实现函数体,当出现同名函数时只需要实现一个就可以,所以不会出现以往的同一个变量指向不明的情况
void main02()
{
	Child c1;
	c1.print();//未使用多态

	Interface1 *it1 = &c1;//定义父类指针
	it1->add(1, 2);//用父类指针指向子类的对象

	Interface2 *it2 = &c1;
	it2->mult(3, 6);
}
2019-07-08 11:10:13 weixin_43778462 阅读数 8
#include<iostream>

using namespace std;
//------------抽象层----------
//抽象的CPU类
class CPU {
public:
	virtual void caculate() = 0;
};

//抽象的显卡类
class Aard {
public:
	virtual void display() = 0;
};

//抽象内存类
class Memory {
public:
	virtual void storage() = 0;
};

//架构类面相抽象类
class Computer {
public:
	Computer(CPU*cpu, Aard*aard, Memory*memory) {
		this->cpu = cpu;
		this->aard = aard;
		this->memory = memory;
	}
	void work() {
		this->cpu->caculate();
		this->aard->display();
		this->memory->storage();
	}
	
private:
	CPU*cpu;
	Aard*aard;
	Memory*memory;
};
//------------------------------------

//--------------实现层----------------
//英特尔公司的CPU
class IntelCPU :public CPU {
public:
	virtual void caculate() {
		cout << "英特尔公司的CPU开始计算了!" << endl;
	}
};
//英特尔公司的Aard
class IntelAard :public Aard {
public:
	virtual void display() {
		cout << "英特尔公司的显卡开始显示了!" << endl;
	}
};
//英特尔公司的memory
class IntelMemory :public Memory {
public:
	virtual void storage() {
		cout << "英特尔公司的内存条开始存储了!" << endl;
	}
};
//金士顿的内存
class KingstonMem :public Memory {
public:
	virtual void storage() {
		cout << "金士顿公司的内存条开始存储了!" << endl;
	}
};
//NVIDIA的显卡
class NVIDIAaard :public Aard {
public:
	virtual void display() {
		cout << "NVIDIA公司的显卡开始显示了!" << endl;
	}
};

//--------------------------------------

//-----------业务层---------------------

int main(void)
{
	//1 组装一台Intel系列的电脑
	CPU*cp = new IntelCPU;
	Aard* aa = new IntelAard;
	Memory* me = new IntelMemory;

	Computer* de=new Computer(cp, aa, me);
	de->work();
	delete aa;
	delete me;
	delete de;

	cout << "----------------------" << endl;
	//2.组装一台CPU是Intel的,显卡是NVIDIA的,内存是Kingston的电脑
	Aard* Naard = new NVIDIAaard;
	Memory* KMemory = new KingstonMem;

	Computer* to = new Computer(cp, Naard, KMemory);
	to->work();
	delete cp;
	delete Naard;
	delete KMemory;
	delete to;
	
}
//--------------------------------------

程序运行结果如下图:
在这里插入图片描述

2013-08-21 01:16:00 weixin_33836223 阅读数 1

我一直从事的是PLC方面的工作,编程的概念也只有PLC专属的编程语言,如梯形图、结构化文本等,随着工业界的发展,也逐渐向IT界靠,也开始接触C、VB之类的东西,没有系统的学过C、VB,都是自己看书或是需要什么功能就去网上寻求答案,所以对C、VB的认知基本为零,随着工作的需要,逐渐也接触多了,开始对此产生了兴趣,因此在这开了博客,以记录我学习的过程。

之前有过c语言的自学,一些基本语法和规则就不再叙述,我将从零开始学C++和JAVA,希望在我入门之前这两门语言不要被淘汰。~~~^_^~~~ (为啥没有插入表情的功能呢?)

最早接触的是java,就从它开始吧。

关于java的由来,百度一下就有很多,这就不多说了,我只记录一些自己认为是重点的东西。

首先是java开发的工具:

JDK:java的开发工具,选择java se版本,安装完成后需要对系统的环境变量进行配置,方法如下:

右键“我的电脑”==》“属性”==》“高级”==》“环境变量”==》在“系统变量中”找到“Path”属性编辑,将java.exe和javac.exe所在的路径添加进去,一般它们在JDK安装目录下的“bin”目录下,最后用“;”结束。

NetBeans IDE:Sun公司提供的一个java开发平台,还没用过,先make,以后用再做记录。

 安装好软件后就开始吧!

基本的概念就不重复了,下面通过实例进行说明:

 1 /*
 2 创建一个圆的模型,通过模型创建2个圆,并分别计算它们的周长和面积
 3 */
 4 
 5 class C    //定义圆的类(模型)
 6 {
 7     private double r;    //定义半径变量r,其中private表示该变量为私有的,除本身的类能访问,其他地方都不能访问
 8     final private double PI = 3.1415926;    //定义PI常量,其中final表示该变量为最终状态,不能修改
 9     
10     public double perimeter()    //定义计算周长函数,其中public表示该函数是公共的,任何地方都能访问
11     {
12         return 2*r*PI;    //计算圆周长
13     }
14     
15     public double area()    //定义计算面积函数
16     {
17         return PI*r*r;    //计算圆面积
18     }
19     
20     public C(double r)    //定义有参构造函数,函数名与类名相同,并且没返回值
21     {
22         this.r = r;    //this.r指的是类的变量,而非函数的变量
23     }
24 
25 }
26 
27 class Round    //定义启动类
28 {
29     public static void main(String[] aaa)    //static表示静态的
30     {
31         C a1 = new C(6.0);    //创建一个对象a1
32         C a2 = new C(3.5);    //创建一个对象a2
33         
34         //printf()函数用法与c语言的一致,只是要注意调用的格式
35         System.out.printf("a1的周长:%f\t", a1.perimeter());
36         System.out.printf("a1的面积:%f\n", a1.area());
37         System.out.printf("a2的周长:%f\t", a2.perimeter());
38         System.out.printf("a2的面积:%f\n", a2.area());
39         System.out.printf("两个圆的周长之和:%f\t", a1.perimeter() + a2.perimeter());
40         System.out.printf("两个圆的面积之和:%f\n", a1.area() + a2.area());
41     }
42 }
43 
44 /*
45 结果:
46 47 a1的周长:37.699111     a1的面积:113.097334
48 a2的周长:21.991148     a2的面积:38.484509
49 两个圆的周长之和:59.690259     两个圆的面积之和:151.581843
50 */

 

 写完以上代码后,保存为*.java的格式,然后打开“命令提示符”,也就是cmd.exe,通过dos命令进入*.java文件所在的文件夹,然后进行以下操作:

1.编译。输入:

javac Round.java

2.运行。输入:

java Round

注意,*.java文件的文件名最好与启动类的名字相同

 

那么,用c++怎么实现上述代码呢?

c++的编译器我用的是C-free,在编译的时候要把腾讯的电脑管家关闭,不然经常会出现电脑管家认为编译的程序是病毒就隔离了,不知道360会不会出现这种情况,晕啊~~

 1 /*
 2  创建一个圆的模型,通过模型创建2个圆,并分别计算它们的周长和面积
 3 */
 4 
 5 #include<stdio.h>    //为了比较,就选择使用stdio.h,而不用iostream 
 6 
 7 class Round    //定义圆的类(模型)
 8 {
 9     private:    //private表示以下定义的变量和函数为私有的,除本身的类能访问,其他地方都不能访问
10         double r;    ////定义半径变量r
11         const static double PI = 3.1415926; //定义PI常量,其中const表示该变量为常量,static表示该变量是静态的,如果没有static,c++不允许在该类的范围内给变量赋值的,而java可以 
12     public:    //public表示以下定义的变量和函数是公共的,任何地方都能访问
13         Round(double r)    //定义有参构造函数,函数名与类名相同,并且没返回值 
14         {
15             this->r = r;    //和java的this意义一样,注意书写方法 
16         }
17         const double perimeter()    //定义计算周长函数,const标识 perimeter()的参数不允许改变 
18         {
19             return 2*PI*r;    ////计算圆周长
20         }
21         const double area()    //定义计算面积函数
22         {
23             return PI*r*r;    //计算圆面积
24         }
25 
26 };     //注意这里需要加分号,java不加分号 
27 
28 int main(void)    //主函数 
29 {
30     Round a1(6.0);    //创建一个对象a1 
31     Round a2(3.5);    //创建一个对象a2
32 
33     printf("a1的周长:%f\t", a1.perimeter());
34     printf("a1的面积:%f\n", a1.area());
35     printf("a2的周长:%f\t", a2.perimeter());
36     printf("a2的面积:%f\n", a2.area());
37     printf("两个圆的周长之和:%f\t", a1.perimeter() + a2.perimeter());
38     printf("两个圆的面积之和:%f\n", a1.area() + a2.area());
39     
40     return 0;
41 }
42 /*
43 结果:
44 47 a1的周长:37.699111     a1的面积:113.097334
45 a2的周长:21.991148     a2的面积:38.484509
46 两个圆的周长之和:59.690259     两个圆的面积之和:151.581843
47 */

 

那么,c又是怎么写呢?

 1 /*
 2 计算圆的周长和面积 
 3 */
 4 
 5 #include<stdio.h>
 6 
 7 const double PI = 3.1415926;
 8 
 9 double perimeter(double r)
10 {
11     return 2*PI*r;
12 }
13 
14 double area(double r)
15 {
16     return PI*r*r;
17 }
18 
19 int main(void)
20 {
21     double r1,r2;
22     
23     r1 = 6.0;
24     r2 = 3.5; 
25     
26     printf("a1的周长:%f\t", perimeter(r1));
27     printf("a1的面积:%f\n", area(r1));
28     printf("a2的周长:%f\t", perimeter(r2));
29     printf("a2的面积:%f\n", area(r2));
30     printf("两个圆的周长之和:%f\t", perimeter(r1) + perimeter(r2));
31     printf("两个圆的面积之和:%f\n", area(r1) + area(r2));
32     
33     return 0;
34 }
35 /*
36 结果:
37 47 a1的周长:37.699111     a1的面积:113.097334
38 a2的周长:21.991148     a2的面积:38.484509
39 两个圆的周长之和:59.690259     两个圆的面积之和:151.581843
40 */

 

小结:

通过上述例子可以看出,java和c++的编程思路和c的编程思路是不同的,c的思路是要解决问题,先把问题分解若干个功能(函数),然后通过调用函数达到解决问题目的;而java和c++增加了对象的概念,思路是先对某个事物的属性和方法(函数)进行封装,也就是创建类,然后通过创建一个一个具体的对象,通过修改对象的属性、调用对象的方法(或类的方法)达到解决问题的目的,这样的编程方法更安全、代码重用率更高、层次感更强,更符合人的逻辑思维。

今天先总结到这儿,以后继续。

转载于:https://www.cnblogs.com/ludong1983/p/3271684.html

C++面向对象模型

阅读数 67

C++面向对象模型,虚函数

博文 来自: wu_wentao

C++面向对象模型

阅读数 2256

学习C++编程的方法

阅读数 787

学习C++编程的方法

阅读数 1018

没有更多推荐了,返回首页