【c/c++】二、C＋＋语言基础

最新推荐文章于 2024-02-28 11:27:19 发布
最新推荐文章于 2024-02-28 11:27:19 发布
阅读量176 收藏
点赞数
分类专栏： C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43525704/article/details/103985221
版权

目录

c++对c的扩展

一、[关键字]

关键字

二、基本数据类型　wchar_t

typedef short int wchar_t;

三、枚举

enum 枚举名{ 
     标识符[=整型常数], 
     标识符[=整型常数], 
... 
    标识符[=整型常数]
} 枚举变量;
//默认情况下，第一个名称的值为 0，第二个名称的值为 1，第三个名称的值为 2，以此类推
enum color { red, green=5, blue };
//在这里，blue 的值为 6，因为默认情况下，每个名称都会比它前面一个名称大 1，但 red 的值依然为 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;
}

交换前，a 的值： 100
交换前，b 的值： 200
交换后，a 的值： 200
交换后，b 的值： 100

⑤引用作为返回值

#include <iostream>
 
using namespace std;
 
double vals[] = {10.1, 12.6, 33.1, 24.1, 50.0};
 
double& setValues( int i )
{
  return vals[i];   // 返回第 i 个元素的引用
}
 
// 要调用上面定义函数的主函数
int main ()
{
 
   cout << "改变前的值" << endl;
   for ( int i = 0; i < 5; i++ )
   {
       cout << "vals[" << i << "] = ";
       cout << vals[i] << endl;
   }
 
   setValues(1) = 20.23; // 改变第 2 个元素
   setValues(3) = 70.8;  // 改变第 4 个元素
 
   cout << "改变后的值" << endl;
   for ( int i = 0; i < 5; i++ )
   {
       cout << "vals[" << i << "] = ";
       cout << vals[i] << endl;
   }
   return 0;
}
－－－－－－－－－－－－－－－－－－－－－－－－－－－
改变前的值
vals[0] = 10.1
vals[1] = 12.6
vals[2] = 33.1
vals[3] = 24.1
vals[4] = 50
改变后的值
vals[0] = 10.1
vals[1] = 20.23
vals[2] = 33.1
vals[3] = 70.8
vals[4] = 50

当返回一个引用时，要注意被引用的对象不能超出作用域。所以返回一个对局部变量的引用是不合法的，但是，可以返回一个对静态变量的引用。

int& func() {
   int q;
   //! return q; // 在编译时发生错误
   static int x;
   return x;     // 安全，x 在函数作用域外依然是有效的
}

五、输入输出

头文件函数和描述
< iostream > .该文件定义了 cin、cout、cerr 和 clog 对象，标准输入流、标准输出流、非缓冲标准错误流和缓冲标准错误流。

六、类与对象

  • 定义一个类，本质上是定义一个数据类型的蓝图。类用于指定对象的形式，它包含了数据表示法和用于处理数据的方法。类中的数据和方法称为类的成员。函数在一个类中被称为类的成员
class Box
{
   public:
      double length;   // 盒子的长度
      double breadth;  // 盒子的宽度
      double height;   // 盒子的高度
};
  • 类提供了对象的蓝图，所以基本上，对象是根据类来创建的。声明类的对象，就像声明基本类型的变量一样。下面的语句声明了类 Box 的两个对象：
Box Box1;          // 声明 Box1，类型为 Box
Box Box2;          // 声明 Box2，类型为 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

需要注意的是，私有的成员和受保护的成员不能使用直接成员访问运算符 (.) 来直接访问。我们将在后续的教程中学习如何访问私有成员和受保护的成员。

类成员函数

#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

类访问修饰符

数据封装是面向对象编程的一个重要特点，它防止函数直接访问类类型的内部成员。类成员的访问限制是通过在类主体内部对各个区域标记 public、private、protected 来指定的。关键字 public、private、protected 称为访问修饰符。
一个类可以有多个 public、protected 或 private 标记区域。每个标记区域在下一个标记区域开始之前或者在遇到类主体结束右括号之前都是有效的。成员和类的默认访问修饰符是 private。
例程

  • public 修饰符：数据可以从外部被访问
  • private修饰符：数据不可从外部访问，只能通过public 的类成员函数访问
  • protected：保护成员变量或函数与私有成员十分相似，但有一点不同，保护成员在派生类（即子类）中是可访问的。

类构造函数

①类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行。
②构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void。构造函数可用于为某些成员变量设置初始值。
③默认的构造函数没有任何参数，但如果需要，构造函数也可以带有参数

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

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

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

类的析构函数

类的析构函数是类的一种特殊的成员函数，它会在每次删除所创建的对象时执行。析构函数的名称与类的名称是完全相同的，只是在前面加了个波浪号（~）作为前缀，它不会返回任何值，也不能带有任何参数。析构函数有助于在跳出程序（比如关闭文件、释放内存等）前释放资源。拷贝构造函数的最常见形式如下：

class Line
{
   public:
      void setLength( double len );
      double getLength( void );
      Line();   // 这是构造函数声明
      ~Line();  // 这是析构函数声明
 
   private:
      double length;
};

类的拷贝构造函数

拷贝构造函数是一种特殊的构造函数，它在创建对象时，是使用同一类中之前创建的对象来初始化新创建的对象。拷贝构造函数通常用于：

  • 通过使用另一个同类型的对象来初始化新创建的对象。

  • 复制对象把它作为参数传递给函数。

  • 复制对象，并从函数返回这个对象。

如果在类中没有定义拷贝构造函数，编译器会自行定义一个。如果类带有指针变量，并有动态内存分配，则它必须有一个拷贝构造函数。拷贝构造函数的最常见形式如下：

classname (const classname &obj) {
   // 构造函数的主体
}

友元函数

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

class Box
{
   double width;
public:
   double length;
   friend void printWidth( Box box );
   void setWidth( double wid );
};
－－－－－－－－－－－－－－－－－－－－－－－－－－－－示例
#include <iostream>
 
using namespace std;
 
class Box
{
   double width;
public:
   friend void printWidth( Box box );
   void setWidth( double wid );
};
 
// 成员函数定义
void Box::setWidth( double wid )
{
    width = wid;
}
 
// 请注意：printWidth() 不是任何类的成员函数
void printWidth( Box box )
{
   /* 因为 printWidth() 是 Box 的友元，它可以直接访问该类的任何成员 */
   cout << "Width of box : " << box.width <<endl;
}
 
// 程序的主函数
int main( )
{
   Box box;
 
   // 使用成员函数设置宽度
   box.setWidth(10.0);
   
   // 使用友元函数输出宽度
   printWidth( box );
 
   return 0;
}

朋友函数，可以访问私密的信息，但是不属于类的成员

内联函数

当函数被声明为内联函数之后, 编译器会将其内联展开, 而不是按通常的函数调用机制进行调用.

#include <iostream>
 
using namespace std;

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

// 程序的主函数
int main( )
{

   cout << "Max (20,10): " << Max(20,10) << endl;
   cout << "Max (0,200): " << Max(0,200) << endl;
   cout << "Max (100,1010): " << Max(100,1010) << endl;
   return 0;
}
－－－－－－－－－－－－－－－－－－－－－－－－－
Max (20,10): 20
Max (0,200): 200
Max (100,1010): 1010

tip
①引入内联函数的目的是为了解决程序中函数调用的效率问题：程序在编译器编译的时候，编译器将程序中出现的内联函数的调用表达式用内联函数的函数体进行替换，而对于其他的函数，都是在运行时候才被替代。
②当函数体比较小的时候, 内联该函数可以令目标代码更加高效. 对于存取函数以及其它函数体比较短, 性能关键的函数, 鼓励使用内联.
③在内联函数内不允许使用循环语句和开关语句
④内联韩式的定义必须出现在内联函数第一次调用之前
⑤类结构中所在的类说明内部定义的函数是内联函数

this指针

在 C++ 中，每一个对象都能通过 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;
}
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
Constructor called.
Constructor called.
Box2 is equal to or larger than Box1

#include <iostream>

using namespace std;

class Box
{
	public:
		Box(){;}
		~Box(){;}
		Box* get_address()
		{
			return this;
		}
};
int main()
{
	Box box1;
	Box box2;
	Box* p = box1.get_address();
	cout << p << endl;
	p = box2.get_address();
	cout << p << endl;
	return 0;
}

this 指针的类型可理解为 Box*。此时得到两个地址分别为 box1 和 box2 对象的地址。

指像类的指针

一个指向 C++ 类的指针与指向结构的指针类似，访问指向类的指针的成员，需要使用成员访问运算符 ->，就像访问指向结构的指针一样。

#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;
      }
   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
   Box *ptrBox;                // Declare pointer to a class.

   // 保存第一个对象的地址
   ptrBox = &Box1;

   // 现在尝试使用成员访问运算符来访问成员
   cout << "Volume of Box1: " << ptrBox->Volume() << endl;

   // 保存第二个对象的地址
   ptrBox = &Box2;

   // 现在尝试使用成员访问运算符来访问成员
   cout << "Volume of Box2: " << ptrBox->Volume() << endl;
  
   return 0;
}
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
Constructor called.
Constructor called.
Volume of Box1: 5.94
Volume of Box2: 102

类的静态成员

我们可以使用 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;
      }
   private:
      double length;     // 长度
      double breadth;    // 宽度
      double height;     // 高度
};
 
// 初始化类 Box 的静态成员
int Box::objectCount = 0;
 
int main(void)
{
   Box Box1(3.3, 1.2, 1.5);    // 声明 box1
   Box Box2(8.5, 6.0, 2.0);    // 声明 box2
 
   // 输出对象的总数
   cout << "Total objects: " << Box::objectCount << endl;
 
   return 0;
}
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
Constructor called.
Constructor called.
Total objects: 2
  • 静态成员函数
    静态成员函数没有 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;
}
笨笨钢铁侠
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C/C++学习路线总结与分享
dvlinker的技术专栏
10-07 8万+
C/C++学习路线总结与分享
c/c++帮助文档中文
04-03
C/C++是两种广泛使用的编程语言，特别是在系统编程、嵌入式开发以及高性能计算领域。这份"c/c++帮助文档中文"提供了丰富的中文资源，帮助开发者深入理解和掌握这两种语言。 C语言是最早由Dennis Ritchie在贝尔实验...
HRESULT中关于S_OK,S_FALSE和 E_FAIL浅析
暂时为空
09-18 5580
S_OK是COM服务器返回正确 S_FALSE是COM服务器返回错误，不过这个错误是可以不处理的，不影响程序正常运行。只是结果不是想要的 E_FAIL是必须处理的错误。 // // HRESULTs are 32 bit values layed out as fo
C++零食：HRESULT 与 Windows Error Codes 不是一回事
aohaizhi7722的博客
08-30 378
在用C++来开发Windows程序时，经常看到下面的判断情况： HRESULT hr = ::RegCreateKeyEx(hk, szKeyPath, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_QUERY_VALUE, NULL, &hk, NULL); if (SUCCEEDED(hr)) { 在代码中，使用SUCCEEDE...
S_OK，S_FALSE，E_FAIL
帘卷西风的专栏
08-24 4844
今天在调试一个ICOP的操作的时候，发现连接被动关闭的时候老是会在一处断言处失败，跟了很久终于发现了问题。在此记录一下： 断言报错的代码如下： HRESULT CIoCPWorker::UnregIoTask(HRESULT hIokey) { ENTER_CALL("CIoCPWorker_UnregIoTask"); ASSERT_(SUCCEEDED(hIokey)); _
S_OK与S_FALSE，E_FAIL
03-18 4830
S_OK是COM服务器返回正确S_FALSE是COM服务器返回错误，不过这个错误是可以不处理的，不影响程序正常运行。只是结果不是想要的 E_FAIL是必须处理的错误。
C/C++爱心代码
兔子王
02-28 8万+
C语言爱心表白代码。
C++入门基础(万字总结）（建议收藏！！！）
热门推荐
IamGreeHand的博客
09-22 25万+
文章目录什么是C++C++的发展史C++关键字命名空间命名空间的定义1.命名空间的普通定义2.命名空间可以嵌套3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。命名空间使用1.加命名空间名称及作用域限定符2.使用using namespace 命名空间名称引入3.使用using将命名空间中的成员引入C++中的输入和输出缺省参数全缺省半缺省参数函数重载函数重载的原理extern “C”引用引用的特征1.引用在定义时必须初始化2.一个变量可以有多个引用3.引用一旦引用了一个实体
VSCode配置C/C++语言环境（小白专用保姆教程）
一枚嵌入式小白菜的摸爬滚打之路
04-01 3万+
集百家之常，最新VSCode C/C++语言环境配置，小白专用
C/C++的发展历程和未来趋势
m0_45463480的博客
06-24 5750
文章目录 C/C++的起源 C/C++的应用 C/C++开发的工具 C/C++未来趋势
C/C++语言特点
08-02
C++语言是基于C语言的基础上发展起来的，二者在基本语法特点方面保持兼并，大多数使用C语言编写的代码可以在C++语言中直接使用。C++语言与C语言的主要区别是编程思想上的更新，即编码由面向过程变为面向对象，基于此...
C/C++语言编程安全子集
02-23
C/C++语言编程安全子集
用Eclipse平台进行C/C++开发
03-05
C和C++语言都是世界上最流行且使用最普遍的编程语言，因此Eclipse平台（EclipsePlatform）提供对C/C++开发的支持一点都不足为奇。因为Eclipse平台只是用于开发者工具的一个框架，它不直接支持C/C++；它使用外部插件...
1.环境搭建.zip_汇编语言_C/C++__汇编语言_C/C++_
08-09
在IT行业中，汇编语言和C/C++是两种至关重要的编程语言，特别是在嵌入式系统开发领域。本文将深入探讨这两个知识点以及它们在液晶显示屏和51单片机开发中的应用。 首先，让我们来理解汇编语言。汇编语言是一种低级...
C++中的几个关键字
That's IT
09-15 1199
1.explicit 在C++中，如果一个类定义了只接受一个参数的构造函数(并且这个参数类型不是该类的指针和引用)，就可以实现从形参类型到这个类类型的隐式转换(这里加一个链接)，但是有时候这种隐式的转换并不是我们希望的，通过在类内部的构造函数声明之前加上explicit关键字，编译器在编译时候就不会进行隐式的转换了。 2.
1203GMT-VB一种N-Channel沟道DFN8(5X6)封装MOS管
最新发布
07-20
1203GMT-VB；Package：DFN8(5X6)；Configuration：Single-N-Channel；VDS：30V；VGS：20（±V）；Vth：1.7V；RDS(ON)=9mΩ@VGS=4.5V；RDS(ON)=7mΩ@VGS=10V；ID：80A；Technology：Trench；

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值