学习C++，伴新同行（通俗版）如有疑问，请在评论区留言

于 2018-01-11 21:04:37 发布
阅读量301 收藏
点赞数 1
文章标签： 入门 C
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yanxinsh/article/details/79038547
版权

建立在C基础上的C++哦！感谢各大博主以及被代码被引用的菜鸟教程！

             day 1

   1.首先C++是一门面向对象的语言。不罗嗦，首先开始概念的解释。

          对象：对象具有状态和动作。 例如： 对象是猫 ：猫的品种，肉球大小，抓，挠都是猫的状态的动作。

          类：(首先解释对象和类的关系，类是描述某对象的模板，例如学生是一大类，而学生李明就是对象)。

     2.然后让我们从一个最简单的实例来进行分析C++的程序。

#include <iostream>    //isotream是C++标准库里的一个头文件
using namespace std;  // 这里是表示使用命名空间std，至于为什么使用看下面
 
// main() 是程序开始执行的地方  
 
int main()
{
   cout << "Hello World"; // 输出 Hello World的语句
   return 0;
}
      上面提到使用了命名空间std，那为什么使用命名空间呢？ 那是因为现在的编程不仅仅只是一个人的工作，而是多个人的团队合作，比如一个项目有两个人负责，分别是A,B负责，而A，B又在不同文件里都使用了变量a，一个定义为float而另一个为int，这样在编译器的编译的链接阶段，就会出现重定义的报错。至于命名空间其他的内容，后期推送。

      然后看一下解释一下在写代码的时候使用的“；”，“；”是语句结束标识，例如：

 a=3;
      而在 块 后不需要加“；”，分号是语句的结束标识，而不是块的。 而块 是语句的集合，用{}包含。例如： 
{a=3;
  b=2;
   c=1;}
有了上面初步的认识后，然后我们继续看：数据类型，循环，判断什么的和C语言相似，所以就先略过了，要是有解释的需要的话可以回复。
3.C++最重要的一点就是面向对象的语言，所以只有在掌握类、对象的相关理论后，才能进行构造自己的代码大厦。

    类：上面已经说了是对象的蓝图，而对于类的定义，我们实际做的是定义了类的对象是什么，包含什么。

    首先在这里我想解释一下，类和结构体是相似的，但是类的范围要远超结构体，至于结构体为什么在C++还存在，大概是为了兼容C吧。不过大家可以根据对结构体已经有的知识来进行类比学习。

     和结构体的struct类似，类是由 class 关键字来进行声明的。class 后跟类的名称。类的主体是包含在一对花括号中。类定义后必须跟着一个分号或一个声明列表。

 例如：我们这样定义一个箱子：

class Box
{
   public:
      double length;   // 盒子的长度
      double breadth;  // 盒子的宽度
      double height;   // 盒子的高度
};
关键字 public 确定了类成员的访问属性。在类对象作用域内，公共成员在类的外部是可访问的。您也可以指定类的成员为 private 或 protected，这个我们以后会进行讲解。

   这样我们就声明了对象的蓝图，即箱子的蓝图，箱子有三个属性，长宽高。然后我们创建对象，如 box1,box2.

   我们这样来创建：

Box Box1;          // 声明 Box1，类型为 Box
Box Box2;          // 声明 Box2，类型为 Box
而每个box都有自己的属性，长，高，宽。

接下来让我们看一看如何进行访问对象。此时可以就像结构体一样，用 成员访问运算符“.”，进行访问操作对象的各种属性，例如：

#include <iostream>
 
using namespace std;
 
class Box
{
   public:
      double length;   // 长度
      double breadth;  // 宽度
      double height;   // 高度
};
 
int main( )
{
   Box Box1;        // 声明 Box1，类型为 Box
   Box Box2;        // 声明 Box2，类型为 Box
   double volume = 0.0;     // 用于存储体积
 
   // box 1 详述
   Box1.height = 5.0; 
   Box1.length = 6.0; 
   Box1.breadth = 7.0;
 
   // box 2 详述
   Box2.height = 10.0;
   Box2.length = 12.0;
   Box2.breadth = 13.0;
 
   // box 1 的体积
   volume = Box1.height * Box1.length * Box1.breadth;
   cout << "Box1 的体积：" << volume <<endl;
 
   // box 2 的体积
   volume = Box2.height * Box2.length * Box2.breadth;
   cout << "Box2 的体积：" << volume <<endl;
   return 0;
}
  编译器编译后，执行的结果是显示： 

Box1 的体积：210
Box2 的体积：1560
注意：使用  . 访问对象的成员仅限于public修饰过的类，如果是private,protected,就不可以了。

先到这里，让我先休息一下，然后继续吧，虽然没有说话，倒是口干舌燥了。  希望大家可以评论关注哦，这样我会更有动力的，o(*￣▽￣*)ブ
                                                                                     day 2

  好的，经过一天的发酵，今天来继续学习吧。 现在再来更为深入的了解一下和类和对象有关其他知识。

1.类成员函数。

   类成员函数指的是那些把函数声明定义写在类里面的函数。他们是类的一部分，也是类的成员之一。而他存在的目的是：操作同类里面的其他变量，访问这些变量的内容。

  首先我们先定义一个Box的类：

class Box
{
   public:
      double length;         // 长度
      double breadth;        // 宽度
      double height;         // 高度
      double getVolume(void);// 返回体积，类成员函数的声明
};
现在我们要使用成员函数来访问类里的成员，而不是用“.”直接来访问类的成员。首先声明了函数，我们需要定义函数getVolume(),我们可以在类里面直接进行定义，也可以在类外使用“：：”域解析运算符来进行定义，来声明该函数是属于Box这个类。首先使用两段代码来进行举例。

首先是使用“：：”域解析运算符来进行定义类成员函数。

double Box::getVolume(void)
{
    return length * breadth * height;
}
然后是在类里面进行函数的定义：（此时是内联函数） 
class Box
{
   public:
      double length;      // 长度
      double breadth;     // 宽度
      double height;      // 高度
   
      double getVolume(void)
      {
         return length * breadth * height;
      }
};
那定义了此函数，我们如何调用该函数呢。我们现在要做的是，使用“.”成员访问运算符来在对象上调用该函数。 

Box myBox;          // 创建一个对象

myBox.getVolume();  // 调用该对象的成员函数

让我们来从一个实例中来看一看如何调用函数： 
#include <iostream>

using namespace std;

class Box
{
   public:
      double length;         // 长度
      double breadth;        // 宽度
      double height;         // 高度

      // 成员函数声明
      double getVolume(void);
      void setLength( double len );
      void setBreadth( double bre );
      void setHeight( double hei );
};

// 成员函数定义
double Box::getVolume(void)
{
    return length * breadth * height;
}

void Box::setLength( double len )
{
    length = len;
}

void Box::setBreadth( double bre )
{
    breadth = bre;
}

void Box::setHeight( double hei )
{
    height = hei;
}

// 程序的主函数
int main( )
{
   Box Box1;                // 声明 Box1，类型为 Box
   Box Box2;                // 声明 Box2，类型为 Box
   double volume = 0.0;     // 用于存储体积
 
   // box 1 详述
   Box1.setLength(6.0); 
   Box1.setBreadth(7.0); 
   Box1.setHeight(5.0);

   // box 2 详述
   Box2.setLength(12.0); 
   Box2.setBreadth(13.0); 
   Box2.setHeight(10.0);

   // box 1 的体积
   volume = Box1.getVolume();
   cout << "Box1 的体积：" << volume <<endl;

   // box 2 的体积
   volume = Box2.getVolume();
   cout << "Box2 的体积：" << volume <<endl;
   return 0;
}
编译器执行后： 
Box1 的体积： 210
Box2 的体积： 1560
2.上面我们提到了pubic，private,protected等访问修饰符，现在来具体说明一下他们的作用。

首先来解释一下封装的概念：一台计算机要想发送数据到另一台计算机，数据首先必须打包，打包过程称为封装。

数据封装是面向对象编程的一个重要特点，它防止函数直接访问类类型的内部成员。

而类中访问权限的设定是由pubic，private,protected等访问修饰符来指定的。一个类可以有多个 public、protected 或 private 标记区域。每个标记区域在下一个标记区域开始之前或者在遇到类主体结束右括号之前都是有效的。成员和类的默认访问修饰符是 private。这个地方要记住啊。

class Base {
 
   public:
 
  // 公有成员
 
   protected:
 
  // 受保护成员
 
   private:
 
  // 私有成员
 
};

1) 公有 成员在程序中类的外部是可访问的。您可以不使用任何成员函数来设置和获取公有变量的值，如下所示： 

#include <iostream>
 
using namespace std;
 
class Line
{
   public:
      double length;
      void setLength( double len );
      double getLength( void );
};
 
// 成员函数定义
double Line::getLength(void)
{
    return length ;
}
 
void Line::setLength( double len )
{
    length = len;
}
 
// 程序的主函数
int main( )
{
   Line line;
 
   // 设置长度
   line.setLength(6.0); 
   cout << "Length of line : " << line.getLength() <<endl;
 
   // 不使用成员函数设置长度
   line.length = 10.0; // OK: 因为 length 是公有的

Length of line : 6
Length of line : 10

cout << "Length of line : " << line.length <<endl; return 0;} 
 
当上面的代码被编译和执行时，它会产生下列结果： 

Length of line : 6
Length of line : 10
 2） 

 

 

 私有成员变量或函数在类的外部是不可访问的，甚至是不可查看的。只有类和友元函数可以访问私有成员。（这个以后再说）
 

 默认情况下，类的所有成员都是私有的。例如在下面的类中，width 是一个私有成员，这意味着，如果您没有使用任何访问修饰符，类的成员将被假定为私有成员：
 

class Box
{
   double width;
   public:
      double length;
      void setWidth( double wid );
      double getWidth( void );
};
 这些私有成员因为不能从外部进行访问，所以要从内部访问，即用内部的内联函数进行访问，例如： 

 
 

#include <iostream>
 
using namespace std;
 
class Box
{
   public:
      double length;
      void setWidth( double wid );
      double getWidth( void );
 
   private:
      double width;
};
 
// 成员函数定义
double Box::getWidth(void)
{
    return width ;
}
 
void Box::setWidth( double wid )
{
    width = wid;
}
 
// 程序的主函数
int main( )
{
   Box box;
 
   // 不使用成员函数设置长度
   box.length = 10.0; // OK: 因为 length 是公有的
   cout << "Length of box : " << box.length <<endl;
 
   // 不使用成员函数设置宽度
   // box.width = 10.0; // Error: 因为 width 是私有的
   box.setWidth(10.0);  // 使用成员函数设置宽度
   cout << "Width of box : " << box.getWidth() <<endl;
 
   return 0;
}
 

 当以上代码被执行后： 

Length of box : 10
Width of box : 10
 3）保护成员protected 

 
 
 
保护 
成员变量或函数与私有成员十分相似，但有一点不同，保护成员在派生类（即子类）中是可访问的。待会儿我们再进行子类的说明。因此对于保护成员我们先暂时不讲。 

 

3.接下来就说明一下子类的概念
 

  在这之前要先谈论一下面向对象的三大特征： 封装（前面已经粗略说明），继承，多态
 

这里我们先讨论下 继承 的概念：
 

 继承通俗来说就是从 亲代 到 子代 特性的传递,不通俗地说就是让某个类型的对象获得另一个类型的对象的属性的方法。 
 

面向对象程序设计中最重要的一个概念是继承。继承允许我们依据另一个类来定义一个类，这使得创建和维护一个应用程序变得更容易。这样做，也达到了重用代码功能和提高执行时间的效果。当创建一个类时，您不需要重新编写新的数据成员和成员函数，只需指定新建的类继承了一个已有的类的成员即可。这个已有的类称为基类，新建的类称为派生类（子类）。例如： 基类是生物，子类可以是：动物，植物
 

一个基类可以有多个派生类，例如：
 

   基类是生物，子类可以是：动物，植物
 

而一个派生类也可以有多个子类,例如   基类：  水果，水——子类：果汁
 

1） 定义一个派生类，我们使用一个类派生列表来指定基类。类派生列表以一个或多个基类命名（多继承），形式如下：
 

class derived-class: access-specifier base-class// class 子类 ：访问修饰符 基类，基类，基类（多继承时候用 ","运算符分隔）
 
其中，访问修饰符 access-specifier 是  
public、protected 
 或  
private 
 其中的一个，base-class 是之前定义过的某个类的名称。如果未使用访问修饰符 access-specifier，则默认为 private。 这里涉及类的继承，所以让我们来说明一下。 

 


 
 

 基类派生子类，该基类可以被继承为 public、protected 或 private 几种类型。继承类型是通过上面讲解的访问修饰符 access-specifier 来指定的。
 

 我们几乎不使用 protected 或 private 继承，通常使用 public 继承。因为前两个的使用范围很小，当使用不同类型的继承时，遵循以下几个规则：
 

  •  公有继承（public）：基类派生子类，基类的公有成员也是派生类的公有成员，基类的保护成员也是派生类的保护成员，基类的私有成员不能直接被派生类访问，但是可以通过调用基类的公有和保护成员来访问。
  •  保护继承（protected）：基类派生子类，基类的公有和保护成员将成为派生类的保护成员。
  •  私有继承（private）：基类派生子类，基类的公有和保护成员将成为派生类的私有成员。
  •   下面就是子类的定义，声明，使用：
     
    #include <iostream>
 
using namespace std;
 
// 基类
class Shape 
{
   public:
      void setWidth(int w)
      {
         width = w;
      }
      void setHeight(int h)
      {
         height = h;
      }
   protected:
      int width;
      int height;
};
 
// 派生类
class Rectangle: public Shape
{
   public:
      int getArea()
      { 
         return (width * height); 
      }
};
 
int main(void)
{
   Rectangle Rect;
 
   Rect.setWidth(5);
   Rect.setHeight(7);
 
   // 输出对象的面积
   cout << "Total area: " << Rect.getArea() << endl;
 
   return 0;
}
     
     
  •  代码执行后：
  •  
    Total area: 35
     好了，就到这里了。下次再见！o(*￣▽￣*)ブ
     
     

                

        

        

    




    

      

        

            

              
                
                  神的失落心
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    1
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                  3
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










              

  



          




        



    





    



      

      

        
      

      





	

		
评论 3

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值