C++ learning

最新推荐文章于 2023-10-18 17:56:03 发布
最新推荐文章于 2023-10-18 17:56:03 发布
阅读量286 收藏
点赞数
分类专栏： C C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SARACH_WONG/article/details/106200191
版权
C 同时被 2 个专栏收录
1 篇文章 0 订阅
订阅专栏
C++
1 篇文章 0 订阅
订阅专栏

从c而来，接触过有一点面向对象的思想，没学过C，此处为了温习c并学c++；参考菜鸟教程

文章目录


C/C++编译器 最常用的免费可用的编译器是 GNU，用 g++ -v检查是否安装了 GCC；

执行g++ -o helloworld helloworld.cpp 得到可运行文件helloworld，命令行输入./helloworld执行；

#include <iostream>
using namespace std;  //告诉编译器使用 std 命名空间。命名空间是 C++ 中一个相对新的概念
int main()
{
    cout << "Hello, world!" << endl;  //可以用‘\n’替换endl，<< 运算符用于向屏幕传多个值。
    return 0;
}

基础教程

基本语法

  • 类是模板
  • 对象是实例
  • 类可以包含多个方法
  • 区分大小写

基本数据类型

  • 使用 sizeof() 函数来获取各种数据类型的大小

typedef

语法：typedef type newname;
eg: typedef int feet;

枚举类型

enum color { red, green, blue } c;
c = blue;

内置类型

类型及大小

变量作用域

  • 当局部变量被定义时，系统不会对其初始化，您必须自行对其初始化。定义全局变量时，系统会自动初始化为下列值

常量

  • 前缀指定基数：0x 或 0X 表示十六进制，0 表示八进制，不带前缀则默认表示十进制。
  • 整数常量也可以带一个后缀，后缀是 U 和 L 的组合，U 表示无符号整数（unsigned），L 表示长整数（long）。后缀可以是大写，也可以是小写，U 和 L 的顺序任意。
  • 字符常量是括在单引号中。如果常量以 **L（仅当大写时）**开头，则表示它是一个宽字符常量（例如 L’x’），此时它必须存储在 wchar_t 类型的变量中。否则，它就是一个窄字符常量（例如 ‘x’），此时它可以存储在 char 类型的简单变量中。

在 C++ 中，有两种简单的定义常量的方式：

  • 使用 #define 预处理器。 #define LENGTH 10
  • 使用 const 关键字。const int LENGTH = 10;

修饰符类型

  • signed、unsigned、long、short
  • 限定符及含义
    • const：const类型的对象在程序执行期间不能被修改改变。
    • volatile：修饰符 volatile 告诉编译器不需要优化volatile声明的变量，让程序可以直接从内存中读取变量。对于一般的变量编译器会对变量进行优化，将内存中的变量值放在寄存器中以加快读写效率。

存储类

参考例子理解。

static

static 存储类指示编译器在程序的生命周期内保持局部变量的存在，而不需要在每次它进入和离开作用域时进行创建和销毁。因此，使用 static 修饰局部变量可以在函数调用之间保持局部变量的值。

extern

存储类用于提供一个全局变量的引用，全局变量对所有的程序文件都是可见的。当您使用 extern 时，对于无法初始化的变量，会把变量名指向一个之前定义过的存储位置。

循环

  • while
  • for
  • do…while

判断

  • if
  • if…else
  • switch
  • Exp1 ? Exp2 : Exp3;

函数

函数参数

  • 传值调用，可以设置默认值
  • 指针调用
  • 引用调用

Lambda 函数与表达式

参考

数字

参考

  • 数学运算 cmath
  • 随机数

基本的输入输出

I/O 库头文件

  • <iostream>
  • <iomanip>
  • <fstream>

标准输入流（cin）

#include <iostream>
 
using namespace std;
 
int main( )
{
   char name[50];
 
   cout << "请输入您的名称： ";
   cin >> name;
   cout << "您的名称是： " << name << endl;
 
}

标准错误流（cerr）

cerr << "Error message : " << str << endl;

标准日志流（clog）

数据结构

访问结构成员

struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
};
Book1.title

结构作为函数参数

void printBook( struct Books book );
int main( )
{
	Books Book1; 
	printBook( Book1 );
}
void printBook( struct Books book )
{
   cout << "书标题 : " << book.title <<endl;
   cout << "书作者 : " << book.author <<endl;
   cout << "书类目 : " << book.subject <<endl;
   cout << "书 ID : " << book.book_id <<endl;
}

指向结构的指针

Books Book1;
printBook( &Book1 );
// struct Books *struct_pointer = &Book1;
void printBook( struct Books *book )
{
   cout << "书标题  : " << book->title <<endl;
   cout << "书作者 : " << book->author <<endl;
   cout << "书类目 : " << book->subject <<endl;
   cout << "书 ID : " << book->book_id <<endl;
}

指针

传递指针给函数

#include <iostream>
#include <ctime>
 
using namespace std;
void getSeconds(unsigned long *par);
 
int main ()
{
   unsigned long sec;
 
 
   getSeconds( &sec );
 
   // 输出实际值
   cout << "Number of seconds :" << sec << endl;
 
   return 0;
}
 
void getSeconds(unsigned long *par)
{
   // 获取当前的秒数
   *par = time( NULL );
   return;
}

从函数返回指针

#include <iostream>
#include <ctime>
#include <cstdlib>
 
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;
}

引用

把引用作为参数

#include <iostream>
using namespace std;
 
// 函数声明
void swap(int& x, int& y);
 
int main ()
{
   // 局部变量声明
   int a = 100;
   int b = 200;
 
   cout << "交换前，a 的值：" << a << endl;
   cout << "交换前，b 的值：" << b << endl;
 
   /* 调用函数来交换值 */
   swap(a, b);
 
   cout << "交换后，a 的值：" << a << endl;
   cout << "交换后，b 的值：" << b << endl;
 
   return 0;
}
 
// 函数定义
void swap(int& x, int& y)
{
   int temp;
   temp = x; /* 保存地址 x 的值 */
   x = y;    /* 把 y 赋值给 x */
   y = temp; /* 把 x 赋值给 y  */
  
   return;
}

把引用作为返回值

参考

引用vs指针

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

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

面向对象

类 & 对象

类构造函数 & 析构函数

类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行。
类的析构函数是类的一种特殊的成员函数，它会在每次删除所创建的对象时执行。

#include <iostream>
 
using namespace std;
 
class Line
{
   public:
      void setLength( double len );
      double getLength( void );
      Line(double len);  // 这是构造函数
      ~Line();  // 这是析构函数声明
 
   private:
      double length;
};
 
// 成员函数定义，包括构造函数
Line::Line( double len)
{
    cout << "Object is being created, length = " << len << endl;
    length = len;
}
Line::~Line(void)
{
    cout << "Object is being deleted" << endl;
}
 
void Line::setLength( double len )
{
    length = len;
}
 
double Line::getLength( void )
{
    return length;
}
// 程序的主函数
int main( )
{
   Line line(10.0);
 
   // 获取默认设置的长度
   cout << "Length of line : " << line.getLength() <<endl;
   // 再次设置长度
   line.setLength(6.0); 
   cout << "Length of line : " << line.getLength() <<endl;
 
   return 0;
}

使用初始化列表来初始化字段

Line::Line( double len): length(len)
{
    cout << "Object is being created, length = " << len << endl;
}

上面的语法等同于如下语法：

Line::Line( double len)
{
    length = len;
    cout << "Object is being created, length = " << len << endl;
}

C::C( double a, double b, double c): X(a), Y(b), Z(c)
{
  //....
}

友元函数

类的友元函数是定义在类外部，但有权访问类的所有私有（private）成员和保护（protected）成员。尽管友元函数的原型有在类的定义中出现过，但是友元函数并不是成员函数。

友元可以是一个函数，该函数被称为友元函数；友元也可以是一个类，该类被称为友元类，在这种情况下，整个类及其所有成员都是友元。

如果要声明函数为一个类的友元，需要在类定义中该函数原型前使用关键字 friend，如下所示：

class Box
{
   double width;
public:
   friend void printWidth( Box box );
   void setWidth( double wid );
};

void printWidth( Box box )
{
   /* 因为 printWidth() 是 Box 的友元，它可以直接访问该类的任何成员 */
   cout << "Width of box : " << box.width <<endl;
}

内联函数

内联函数在编译时候直接替换

inline int Max(int x, int y)
{
   return (x > y)? x : y;
}

入内联函数的目的是为了解决程序中函数调用的效率问题，这么说吧，程序在编译器编译的时候，编译器将程序中出现的内联函数的调用表达式用内联函数的函数体进行替换，而对于其他的函数，都是在运行时候才被替代。这其实就是个空间代价换时间的i节省。所以内联函数一般都是1-5行的小函数。在使用内联函数时要留神：

  1. 在内联函数内不允许使用循环语句和开关语句；
  2. 内联函数的定义必须出现在内联函数第一次调用之前；
  3. 类结构中所在的类说明内部定义的函数是内联函数。

this

每一个对象都能通过 this 指针来访问自己的地址。this 指针是所有成员函数的隐含参数。因此，在成员函数内部，它可以用来指向调用对象。

#include <iostream>
 
using namespace std;
 
class Box
{
   public:
      // 构造函数定义
      Box(double l=2.0, double b=2.0, double h=2.0)
      {
         cout <<"Constructor called." << endl;
         length = l;
         breadth = b;
         height = h;
      }
      double Volume()
      {
         return length * breadth * height;
      }
      int compare(Box box)
      {
         return this->Volume() > box.Volume();
      }
   private:
      double length;     // Length of a box
      double breadth;    // Breadth of a box
      double height;     // Height of a box
};
 
int main(void)
{
   Box Box1(3.3, 1.2, 1.5);    // Declare box1
   Box Box2(8.5, 6.0, 2.0);    // Declare box2
 
   if(Box1.compare(Box2))
   {
      cout << "Box2 is smaller than Box1" <<endl;
   }
   else
   {
      cout << "Box2 is equal to or larger than Box1" <<endl;
   }
   return 0;
}

类的静态成员

我们可以使用 static 关键字来把类成员定义为静态的。当我们声明类的成员为静态时，这意味着无论创建多少个类的对象，静态成员都只有一个副本。我们不能把静态成员的初始化放置在类的定义中，但是可以在类的外部通过使用范围解析运算符 :: 来重新声明静态变量从而对它进行初始化。

静态成员在类的所有对象中是共享的，可以用来统计为这个类创建了几个对象。静态成员函数即使在类对象不存在的情况下也能被调用，静态函数只要使用类名加范围解析运算符 :: 就可以访问。

#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;
}

结果：

Inital Stage Count: 0
Constructor called.
Constructor called.
Final Stage Count: 2

继承

#include <iostream>
 
using namespace std;
 
// 基类 Shape
class Shape 
{
   public:
      void setWidth(int w)
      {
         width = w;
      }
      void setHeight(int h)
      {
         height = h;
      }
   protected:
      int width;
      int height;
};
 
// 基类 PaintCost
class PaintCost 
{
   public:
      int getCost(int area)
      {
         return area * 70;
      }
};
 
// 派生类
class Rectangle: public Shape, public PaintCost
{
   public:
      int getArea()
      { 
         return (width * height); 
      }
};
 
int main(void)
{
   Rectangle Rect;
   int area;
 
   Rect.setWidth(5);
   Rect.setHeight(7);
 
   area = Rect.getArea();
   
   // 输出对象的面积
   cout << "Total area: " << Rect.getArea() << endl;
 
   // 输出总花费
   cout << "Total paint cost: $" << Rect.getCost(area) << endl;
 
   return 0;
}

派生类可以访问基类中所有的非私有成员。一个派生类继承了所有的基类方法，但下列情况除外：

  • 基类的构造函数、析构函数和拷贝构造函数。
  • 基类的重载运算符。
  • 基类的友元函数。

重载运算符和重载函数

C++ 允许在同一作用域中的某个函数和运算符指定多个定义，分别称为函数重载和运算符重载。

重载声明是指一个与之前已经在该作用域内声明过的函数或方法具有相同名称的声明，但是它们的参数列表和定义（实现）不相同。

当您调用一个重载函数或重载运算符时，编译器通过把您所使用的参数类型与定义中的参数类型进行比较，决定选用最合适的定义。选择最合适的重载函数或重载运算符的过程，称为重载决策。

函数重载
#include <iostream>
using namespace std;
 
class printData
{
   public:
      void print(int i) {
        cout << "整数为: " << i << endl;
      }
 
      void print(double  f) {
        cout << "浮点数为: " << f << endl;
      }
 
      void print(char c[]) {
        cout << "字符串为: " << c << endl;
      }
};
 
int main(void)
{
   printData pd;
 
   // 输出整数
   pd.print(5);
   // 输出浮点数
   pd.print(500.263);
   // 输出字符串
   char c[] = "Hello C++";
   pd.print(c);
 
   return 0;
}
运算符重载
#include <iostream>
using namespace std;
 
class Box
{
   public:
 
      double getVolume(void)
      {
         return length * breadth * height;
      }
      void setLength( double len )
      {
          length = len;
      }
 
      void setBreadth( double bre )
      {
          breadth = bre;
      }
 
      void setHeight( double hei )
      {
          height = hei;
      }
      // 重载 + 运算符，用于把两个 Box 对象相加
      Box operator+(const Box& b)
      {
         Box box;
         box.length = this->length + b.length;
         box.breadth = this->breadth + b.breadth;
         box.height = this->height + b.height;
         return box;
      }
   private:
      double length;      // 长度
      double breadth;     // 宽度
      double height;      // 高度
};
// 程序的主函数
int main( )
{
   Box Box1;                // 声明 Box1，类型为 Box
   Box Box2;                // 声明 Box2，类型为 Box
   Box Box3;                // 声明 Box3，类型为 Box
   double volume = 0.0;     // 把体积存储在该变量中
 
   // Box1 详述
   Box1.setLength(6.0); 
   Box1.setBreadth(7.0); 
   Box1.setHeight(5.0);
 
   // Box2 详述
   Box2.setLength(12.0); 
   Box2.setBreadth(13.0); 
   Box2.setHeight(10.0);
 
   // Box1 的体积
   volume = Box1.getVolume();
   cout << "Volume of Box1 : " << volume <<endl;
 
   // Box2 的体积
   volume = Box2.getVolume();
   cout << "Volume of Box2 : " << volume <<endl;
 
   // 把两个对象相加，得到 Box3
   Box3 = Box1 + Box2;
 
   // Box3 的体积
   volume = Box3.getVolume();
   cout << "Volume of Box3 : " << volume <<endl;
 
   return 0;
}

各种运算符重载的实例

多态

虚函数

class Shape {
   protected:
      int width, height;
   public:
      Shape( int a=0, int b=0)
      {
         width = a;
         height = b;
      }
      virtual int area()
      {
         cout << "Parent class area :" <<endl;
         return 0;
      }
};

虚函数 是在基类中使用关键字 virtual 声明的函数。在派生类中重新定义基类中定义的虚函数时，会告诉编译器不要静态链接到该函数。

我们想要的是在程序中任意点可以根据所调用的对象类型来选择调用的函数，这种操作被称为动态链接，或后期绑定。

纯虚函数

您可能想要在基类中定义虚函数，以便在派生类中重新定义该函数更好地适用于对象，但是您在基类中又不能对虚函数给出有意义的实现，这个时候就会用到纯虚函数。
我们可以把基类中的虚函数 area() 改写如下，= 0 告诉编译器，函数没有主体，上面的虚函数是纯虚函数。

class Shape {
   protected:
      int width, height;
   public:
      Shape( int a=0, int b=0)
      {
         width = a;
         height = b;
      }
      // pure virtual function
      virtual int area() = 0;
};

高级教程

命名空间

您可以使用 using namespace 指令，这样在使用命名空间时就可以不用在前面加上命名空间的名称。这个指令会告诉编译器，后续的代码将使用指定的命名空间中的名称。

#include <iostream>
using namespace std;
 
// 第一个命名空间
namespace first_space{
   void func(){
      cout << "Inside first_space" << endl;
   }
}
// 第二个命名空间
namespace second_space{
   void func(){
      cout << "Inside second_space" << endl;
   }
}
int main ()
{
 
   // 调用第一个命名空间中的函数
   first_space::func();
   
   // 调用第二个命名空间中的函数
   second_space::func(); 
 
   return 0;
}

预处理器

#define 预处理

#define PI 3.14159

参数宏

#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;
}

预定义宏

#include <iostream>
using namespace std;
 
int main ()
{
    cout << "Value of __LINE__ : " << __LINE__ << endl;
    cout << "Value of __FILE__ : " << __FILE__ << endl;
    cout << "Value of __DATE__ : " << __DATE__ << endl;
    cout << "Value of __TIME__ : " << __TIME__ << endl;
 
    return 0;
}

Q

  • virtual
  • 析构函数 用于程序退出或者删除类的对象的时候调用
  • :: namepace
  • : 继承符号 class Rectangle: public Shape, public PaintCost， 多重继承
  • Shape( int a=0, int b=0) 构造函数
  • Adder adder = Adder(5);
  • 类访问修饰符 public:
  • 纯虚函数 virtual double getVolume() = 0;
  • e.what() 是异常类提供的一个公共方法，它已被所有子异常类重载。这将返回异常产生的原因
  • static 无论是否为类创建对象，都可以通过::访问静态成员/静态成员函数。静态成员在所有对象中共享。
  • this 相当于Box*。
  • 内联函数在编译时候会直接替换而不是在运行时候（编译器试图在调用函数的地方扩展函数体中的代码），相当于用空间换时间。因此内联函数中不能有判断运算等。
  • 友元函数可以访问类的 private 和 protected 成员。
  • c++模板 vector<T>
  • # 和 ## 运算符
  • 信号处理
  • 多线程
  • Web 编程
joshuwang0810
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++学习
学习成神之路
12-23 375
各种函数库： include<cstdio>" role="presentation" style="position: relative;">cstdio>cstdio>用printf和scanf要调用 include<cstdlib>" role="presentation" style="position: relative;">cstdlib>cstdlib>有
c++learn
qq_48079941的博客
07-27 152
查找指定的元素是否存在(二分查找) bool binary_search( iterator beg, iterator end, value);c++中,函数的形参列表中的形参是可以有默认值的,调用函数时没有传入参数就用默认值，如果传入了参数就用传入的参数。统计元素个数 count( iterator beg, iterator end, value);两个派生类继承同一个基类，又有某个类同时继承这两个派生类，这种继承被称为菱形继承，或者钻石继承。
C++ Learning （Next）
Cappuccino Blog
04-07 1434
第五章 循环和关系表达式 5.1 for循环 使用for循环访问字符串 #include <iostream> #include <string> using namespace std; int main() { cout << "Enter a word: "; string word; cin >> word; //display letters in reverse order for(int i =
C++learning
mr_beanna的博客
05-20 232
//常量宏 #define PI 3.14 #define STU_COUNT 102 //宏模拟函数 #define ARRDY_SIZE(a) sezeof(a)/sizeof(a[0]) // 控制宏 declaration vs. definition /* 头文件定义 #ifndef TEST_H #define TEST_H struct A{ int i; }; #endif */ // 头文件中若要调用C中的函数 /* #ifdef __cplusplus extern "C" { #end
c++_learning-基础部分
qq_44599368的博客
10-18 551
基础知识、基础语法：c++程序的内存分布、静态/动态分配内存、函数/类中的静态对象与全局对象的构造顺序、临时对象、深/浅拷贝的问题、std::move()和std::ref()的对比、函数新特性、函数重载、inline内联函数、函数中const的使用、递归函数、c++中的I/O流、I/O缓存区、文件操作。
基于Q-learning的无人机三维路径规划（含完整C++代码）
热门推荐
weixin_54186646的博客
04-27 1万+
基于Q-learning的无人机三维路径规划（含完整C++代码）
CS 106B C++ learning.zip
08-22
【标题】"CS 106B C++ learning.zip" 提供的是关于加州大学斯坦福分校的CS 106B课程的C++学习资源，这是一门中级到高级的计算机科学课程，专注于使用C++语言进行程序设计。C++是一种强类型、面向对象的编程语言，...
c++ learning
08-05
在C++编程语言中，"继承与派生"是面向对象编程的重要概念。在这个主题下，我们可以看到两个关键知识点：1) 公有继承（Public Inheritance）和 2) 派生类（Derived Class）。 公有继承是指一个类（派生类）可以公开...
Learning C++
06-03
Free unaffiliated eBook created from Stack Overflow contributors，including many aspects of C++ and C++ new standard
Q-Learning强化学习的代码实现
12-21
代码用vs2008 c# 实现 状态维数5维，动作维数5维，可以使用网络调试助手连接调试，具体内容见代码
Learning C++ Functional Programming epub
09-23
Learning C++ Functional Programming 英文epub 本资源转载自网络，如有侵权，请联系上传者或csdn删除 本资源转载自网络，如有侵权，请联系上传者或csdn删除
Learning C++ Functional Programming
08-14
Learning C++ Functional Programming by Wisnu Anggoro English | 10 Aug. 2017 | ISBN: 1787281973 | ASIN: B06WVD7CVT | 304 Pages | AZW3 | 2.4 MB Key Features Modularize your applications and make them ...
强化学习：Q-learning的C语言实现
weixin_40571937的博客
12-12 4594
强化学习：Q-Learning学习笔记（C语言实现） 一. 强化学习（增强学习）的概念： 机器学习算法大致可以分为三种： 1. 监督学习(如回归，分类) 2. 非监督学习(如聚类，降维) 3. 强化学习 什么是强化学习呢？ 强化学习（reinforcementlearning, RL）又叫做增强学习，是近年来机器学习和智能控制领域的主要方法之一。 定义: Reinforcement lear...
C++ Learn from菜鸟教程
LJQ的博客
10-08 208
C++每日积累收获2019/10/3 收获 2019/10/3 收获 typedef 可以为一个已有的类型取一个新的名字： typedef type newname eg: typedef int feet, ----- feet 为int的一个别称。则可以feet distance；定义了一个整型变量 diatance。 extern 关键字–声明变量或者函数 eg: extern int ...
C++ Learning
Cappuccino Blog
04-01 533
第二章 C++的学习 为查看输出，必须在程序的最后加上一些代码： cin.get(); //读取下一次键击，因此上述语句让程序等待，直到按下了Enter键 C语言输入和输出 如果已经使用过C语言进行编程，则看到cout函数（而不是printf（）函数）时可能会诧异。事实上C++能够使用printf（）、scanf（）和其他所有标准C输入和输出函数，只需要包含常规C语言的stdio.h文件。使用C++的输入工具，它们在C版本的基础上作出了很多改进。 注释，由前缀//标识 预处理器编译指令#include
Learn C++学习笔记：第十一章—继承
weixin_39548859的博客
12-27 136
继承简介 C++继承语法非常简单，在class声明之后，我们使用冒号，单词“ public”以及我们希望继承的类的名称。这称为公共继承。 #include <iostream> class Base { public: int m_id; Base(int id=0) : m_id(id) { std::cout <...
Learning C++之 1.4 函数和返回值
yingmuliuchuan的博客
03-14 154
函数是一个可以实现特定功能不断重复使用的一系列语句。前面已经说过每个程序都必须有一个主函数：main()。然而多数程序都用到了很多个函数。通常来说，你的程序有时候在运行的时候可能需要中断一下去做其他事情。你在生活中也常常遇到这些事情，举个例子。当你读书时，你接到了一个电话。这个时候你就需要对书做一个标记，然后去接电话，接完电话后再去接着读书。C++程序也是如此，程序都是按顺序执行着，知道遇到一个函...
基于Springboot和Vue的数码论坛系统设计与实现-源码 数码论坛系统设计与实现代码（高分毕设）
最新发布
07-24
数码论坛系统设计与实现-源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！ 系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！ 系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！
C++ Primer Fourth Edition: Modern Learning Guide
"C++Primer英文版，第四版，适合与中文版配合使用，学习英语并直接阅读原版书籍。本书由Stanley B. Lippman, Josée Lajoie和Barbara E. Moo共同撰写，由Addison Wesley Professional出版社出版，发布日期为2005年2...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值