【在线学习系列】C++简略

2017-4-24 二赛君 学习笔记

timg.jpg

Runoob

部分记录

1. C++ 四大特性:

     封装     数据隐藏     继承      多态

三个重要组成部分:

     核心语言    C++标准库      标准模板库

2. C++标识符区分大小写

     C++关键字

asm
else new this
auto enum operator throw
bool explicit private true
break export protected try
case extern public typedef
catch false register typeid
char float reinterpret_cast typename
class for return union
const friend short unsigned
const_cast goto signed using
continue if sizeof virtual
default inline static void
delete int static_cast volatile
do long struct wchar_t
double mutable switch while
dynamic_cast namespace template  

3. 数据类型

   

类型
范围
char 1 个字节 -128 到 127 或者 0 到 255
unsigned char 1 个字节 0 到 255
signed char 1 个字节 -128 到 127
int 4 个字节 -2147483648 到 2147483647
unsigned int 4 个字节 0 到 4294967295
signed int 4 个字节 -2147483648 到 2147483647
short int 2 个字节 -32768 到 32767
unsigned short int 2 个字节 0 到 65,535
signed short int 2 个字节 -32768 到 32767
long int 8 个字节 -9,223,372,036,854,775,808 到 9,223,372,036,854,775,807
signed long int 8 个字节 -9,223,372,036,854,775,808 到 9,223,372,036,854,775,807
unsigned long int 8 个字节 0 to 18,446,744,073,709,551,615
float 4 个字节 +/- 3.4e +/- 38 (~7 个数字)
double 8 个字节 +/- 1.7e +/- 308 (~15 个数字)
long double 8 个字节 +/- 1.7e +/- 308 (~15 个数字)
wchar_t 2 或 4 个字节 1 个宽字符

typedef声明

     typedef type newname

4. 变量

extern

volatile : 修饰符告诉编译器,变量的值可能以程序未明确的方式被改变。

初始化局部变量和全局变量

     当局部变量被定义时,系统不会对其初始化,必须自行对其初始化

     定义全局变量时,系统会自动初始化为下列值:

数据类型
初始化默认值
int 0
char '\0'
float 0
double 0
pointer NULL

5. 常量   

#define

#define identifier value

const : 对象在执行期间不能被修改改变

6. 存储类

static :在程序生命周期内保持局部变量的存在,不需要每次进入和离开作用域时进行创建和销毁。

     也可应用于全局变量,其作用域限制在声明它的文件里。

7. 运算符

成员运算符  .  或者 ->  :访问结构的成员时,使用点运算符,通过指针访问结构成员时,使用箭头运算符

强制转换运算符 cast  : const_cast<type>    dynamic_cast<type>    reinterpret_cast<type>    static_cast<type> 

8. 循环

  for(init;condition;increment)

    init 只会执行一次

基于范围的 for 循环 (C++11)


int my_array[5] = {1, 2, 3, 4, 5};
// 每个数组元素乘于 2
for (int &x : my_array)
{
    x *= 2;
    cout << x << endl;  
}
// auto 类型也是 C++11 新标准中的,用来自动获取变量的类型
for (auto &x : my_array) {
    x *= 2;
    cout << x << endl;  
}

上面for述句的第一部分定义被用来做范围迭代的变量,就像被声明在一般for循环的变量一样,其作用域仅只于循环的范围。而在":"之后的第二区块,代表将被迭代的范围。


9. switch 语句的 expression 必须是一个整型 或者 枚举类型

10. 函数

函数接口的变量为形式参数,在进入函数被创建,退出函数时被销毁。

当函数调用时,有两种不同的函数传递参数方式:


调用类型
描述
传值调用 该方法把参数的实际值复制给函数的形式参数。在这种情况下,修改函数内的形式参数对实际参数没有影响
指针调用 该方法把参数的地址复制给形式参数。在函数内,该地址用于访问调用中要用到的实际参数。这意味着,修改形式参数会影响实际参数。
引用调用 该方法把参数的引用复制给形式参数,也就把参数地址复制给形式参数。在函数内,该引用用于访问调用中要用到的实际参数。这意味着,修改形式参数会影响实际参数。

默认是传值调用

void swap(int x, int y)

指针调用

void swap(int *x, int *y)

引用调用

void swap(int &x, int &y)

11. 数学头文件 <cmath>

生成随机数,先调用 srand(),在调用 rand();

12. 数组


C++ 不允许返回一个完整的数组作为函数的参数。但是,您可以通过指定不带索引的数组名来返回一个指向数组的指针。

如果您想要从函数返回一个一维数组,您必须声明一个返回指针的函数,如下:

int * myFunction()
{
.
.
.
}

另外,C++ 不支持在函数外返回局部变量的地址,除非定义局部变量为 static 变量

现在,让我们来看下面的函数,它会生成 10 个随机数,并使用数组来返回它们,具体如下:

#include <iostream>
#include <cstdlib>
#include <ctime>
 
using namespace std;
 
// 要生成和返回随机数的函数
int * getRandom( )
{
  static int  r[10];
 
  // 设置种子
  srand( (unsigned)time( NULL ) );
  for (int i = 0; i < 10; ++i)
  {
    r[i] = rand();
    cout << r[i] << endl;
  }
 
  return r;
}
 
// 要调用上面定义函数的主函数
int main ()
{
   // 一个指向整数的指针
   int *p;
 
   p = getRandom();
   for ( int i = 0; i < 10; i++ )
   {
       cout << "*(p + " << i << ") : ";
       cout << *(p + i) << endl;
   }
 
   return 0;
}
624723190
1468735695
807113585
976495677
613357504
1377296355
1530315259
1778906708
1820354158
667126415
*(p + 0) : 624723190
*(p + 1) : 1468735695
*(p + 2) : 807113585
*(p + 3) : 976495677
*(p + 4) : 613357504
*(p + 5) : 1377296355
*(p + 6) : 1530315259
*(p + 7) : 1778906708
*(p + 8) : 1820354158
*(p + 9) : 667126415


13. 引用


引用很容易与指针混淆,它们之间有三个主要的不同:

  • 不存在空引用。引用必须连接到一块合法的内存。
  • 一旦引用被初始化为一个对象,就不能被指向到另一个对象。指针可以在任何时候指向到另一个对象。
  • 引用必须在创建时被初始化。指针可以在任何时间被初始化。


14. 类

在基类中定义 虚函数,是为了在派生类中实现具体定义。基类中虚函数 = 0 则为 纯虚函数,有纯虚函数的类为抽象类。

一般在私有区域定义数据,在共有区域定义相关函数, 以便类的外部也可以调用这些函数,而这些函数可以对私有数据进行修改赋值等操作。

默认修饰符是 private

友元函数:有权访问类的保护和私有成员。尽管友元函数在类中出现过,但友元函数不是成员函数。

this指针:每个对象都可通过this来访问自己的地址。

类的静态成员,静态函数在类对象不存在的情况下也可被调用静态成员函数只能访问静态数据成员。

#include <iostream>
 
using namespace std;

class Box
{
   public:
      static int objectCount;
      // 构造函数定义
      Box(double l=2.0, double b=2.0, double h=2.0)
      {
         cout <<"Constructor called." << endl;
         length = l;
         breadth = b;
         height = h;
         // 每次创建对象时增加 1
         objectCount++;
      }
      double Volume()
      {
         return length * breadth * height;
      }
      static int getCount()
      {
         return objectCount;
      }
   private:
      double length;     // 长度
      double breadth;    // 宽度
      double height;     // 高度
};

// 初始化类 Box 的静态成员
int Box::objectCount = 0;

int main(void)
{
  
   // 在创建对象之前输出对象的总数
   cout << "Inital Stage Count: " << Box::getCount() << endl;

   Box Box1(3.3, 1.2, 1.5);    // 声明 box1
   Box Box2(8.5, 6.0, 2.0);    // 声明 box2

   // 在创建对象之后输出对象的总数
   cout << "Final Stage Count: " << Box::getCount() << endl;

   return 0;
}

15. 运算符重载

Box operator+(const Box&);

++和-- 运算符重载: 注意重载前缀与后缀


// 重载前缀递增运算符( ++ )
      Time operator++ ()  
      {
         ++minutes;          // 对象加 1
         if(minutes >= 60)  
         {
            ++hours;
            minutes -= 60;
         }
         return Time(hours, minutes);
      }
      // 重载后缀递增运算符( ++ )
      Time operator++( int )         
      {
         // 保存原始值
         Time T(hours, minutes);
         // 对象加 1
         ++minutes;                    
         if(minutes >= 60)
         {
            ++hours;
            minutes -= 60;
         }
         // 返回旧的原始值
         return T; 
      }

16. 动态内存

内存分:

    栈:在函数内部声明的所有变量都将占有栈内存。

    堆:这是程序中未使用的内存,在程序运行时可用于动态内存分配。

malloc() 在C语言中出现,在C++中依然存在,但建议尽量不要使用。new()与其相比主要优点在于不仅分配了没存还创建了对象。

不需要分配的动态内存时,使用 delete 释放所占用的内存。

17. 条件编译

#define

函数宏  #define MIN(a,b) (a<b ? a : b)

有选择的进行编译,称为条件编译。


#include <iostream>
using namespace std;
#define DEBUG
 
#define MIN(a,b) (((a)<(b)) ? a : b)
 
int main ()
{
   int i, j;
   i = 100;
   j = 30;
#ifdef DEBUG
   cerr <<"Trace: Inside main function" << endl;
#endif
 
#if 0
   /* 这是注释部分 */
   cout << MKSTR(HELLO C++) << endl;
#endif
 
   cout <<"The minimum is " << MIN(i, j) << endl;
 
#ifdef DEBUG
   cerr <<"Trace: Coming out of main function" << endl;
#endif
    return 0;
}
Trace: Inside main function
The minimum is 30
Trace: Coming out of main function


小结:C++的内容远不止这些,上述的内容只是皮毛中的皮毛。很多内容没有具体涉及,在以后的学习科研中还要不断的积累。

学,无止境。   

在线学习系列文章,C++简略。

    文章地址:http://www.ersaijun.cn/ersaijun/?post=163

     二赛君

    2017.05.13




标签: 在线学习 C++

发表评论:

Copyright 2011-2017 | Powered by emlog | Redesigned by Kaspar.s
京ICP备13003113号 sitemap